﻿using System;
using System.Collections.Generic;
using SharpSqlAnalyzer.nodes;
using SharpSqlAnalyzer.nodes.mssql;
using SharpSqlAnalyzer.nodes.mysql;
using SharpSqlAnalyzer.nodes.oracle;
using SharpSqlAnalyzer.stmt;
using SharpSqlAnalyzer.stmt.mssql;
using SharpSqlAnalyzer.stmt.oracle;

namespace SharpSqlAnalyzer.scriptWriter
{
	// Token: 0x020001EF RID: 495
	public class TScriptGeneratorVisitor : TParseTreeVisitor
	{
		// Token: 0x060010A9 RID: 4265 RVA: 0x0030D2D4 File Offset: 0x0030B4D4
		internal virtual void acceptToken(TSourceToken st)
		{
			this.scriptWriter.addToken(st);
		}

		// Token: 0x060010AA RID: 4266 RVA: 0x0030D2E2 File Offset: 0x0030B4E2
		internal virtual void acceptSymbol(string symbol)
		{
			this.scriptWriter.addSymbol(symbol);
		}

		// Token: 0x060010AB RID: 4267 RVA: 0x0030D2F0 File Offset: 0x0030B4F0
		internal virtual void acceptSymbol(string symbol, int tokenCode)
		{
			this.scriptWriter.addSymbol(symbol, tokenCode);
		}

		// Token: 0x060010AC RID: 4268 RVA: 0x0030D2FF File Offset: 0x0030B4FF
		internal virtual void acceptKeyword(TSourceToken st)
		{
			if (st != null)
			{
				this.scriptWriter.addKeyword(st.ToString());
			}
		}

		// Token: 0x060010AD RID: 4269 RVA: 0x0030D315 File Offset: 0x0030B515
		internal virtual void acceptKeyword(string keyword)
		{
			this.scriptWriter.addKeyword(keyword);
		}

		// Token: 0x060010AE RID: 4270 RVA: 0x0030D323 File Offset: 0x0030B523
		internal virtual void acceptNewline()
		{
			this.scriptWriter.addNewline();
		}

		// Token: 0x060010AF RID: 4271 RVA: 0x0030D330 File Offset: 0x0030B530
		internal virtual void acceptSemicolon()
		{
			this.scriptWriter.addSemicolon();
		}

		// Token: 0x060010B0 RID: 4272 RVA: 0x0030D33D File Offset: 0x0030B53D
		internal virtual void acceptSpace(int count)
		{
			this.scriptWriter.addSpace(count);
		}

		// Token: 0x060010B1 RID: 4273 RVA: 0x0030D34B File Offset: 0x0030B54B
		internal virtual void acceptLiteral(string literal)
		{
			this.scriptWriter.addLiteral(literal);
		}

		// Token: 0x060010B2 RID: 4274 RVA: 0x0030D359 File Offset: 0x0030B559
		internal virtual void acceptIdentifier(string identifier)
		{
			this.scriptWriter.addIdentifier(identifier);
		}

		// Token: 0x060010B3 RID: 4275 RVA: 0x0030D367 File Offset: 0x0030B567
		internal virtual void acceptOracleHint(string identifier)
		{
			this.scriptWriter.acceptOracleHint(identifier);
		}

		// Token: 0x060010B4 RID: 4276 RVA: 0x0030D375 File Offset: 0x0030B575
		public TScriptGeneratorVisitor(TScriptWriter scriptWriter)
		{
			this.scriptWriter = scriptWriter;
		}

		// Token: 0x060010B5 RID: 4277 RVA: 0x0030D384 File Offset: 0x0030B584
		public override void preVisit(TConstant node)
		{
			this.acceptLiteral(node.String);
		}

		// Token: 0x060010B6 RID: 4278 RVA: 0x0030D394 File Offset: 0x0030B594
		public override void preVisit(TObjectName node)
		{
			if (node.ServerToken != null)
			{
				this.acceptIdentifier(node.ServerToken.ToString());
				this.acceptSymbol(".");
			}
			if (node.DatabaseToken != null)
			{
				this.acceptIdentifier(node.DatabaseToken.ToString());
				this.acceptSymbol(".");
			}
			if (node.SchemaToken != null)
			{
				this.acceptIdentifier(node.SchemaToken.ToString());
				this.acceptSymbol(".");
			}
			if (node.ObjectToken != null)
			{
				this.acceptIdentifier(node.ObjectToken.ToString());
			}
			if (node.PartToken != null)
			{
				if (node.ObjectToken != null)
				{
					this.acceptSymbol(".");
				}
				this.acceptIdentifier(node.PartToken.ToString());
			}
			if (node.Dblink != null)
			{
				this.acceptSymbol("@");
				node.Dblink.accept(this);
				return;
			}
			if (node.Exclamationmark != null)
			{
				this.acceptSymbol("@");
				this.acceptSymbol("!");
			}
		}

		// Token: 0x060010B7 RID: 4279 RVA: 0x0030D490 File Offset: 0x0030B690
		public override void preVisit(TExpressionList node)
		{
			for (int i = 0; i < node.Count; i++)
			{
				node.getExpression(i).accept(this);
				if (i != node.Count - 1)
				{
					this.acceptSymbol(",");
				}
			}
		}

		// Token: 0x060010B8 RID: 4280 RVA: 0x0030D4D1 File Offset: 0x0030B6D1
		public override void preVisit(TExpressionCallTarget node)
		{
			node.Expr.accept(this);
		}

		// Token: 0x060010B9 RID: 4281 RVA: 0x0030D4E0 File Offset: 0x0030B6E0
		public override void preVisit(TFunctionCall node)
		{
			if (node.CallTarget != null)
			{
				node.CallTarget.accept(this);
				this.acceptSymbol(".");
			}
			node.FunctionName.accept(this);
			this.acceptSymbol("(");
			switch (node.AggregateType)
			{
			case EAggregateType.all:
				this.acceptKeyword("all");
				break;
			case EAggregateType.distinct:
				this.acceptKeyword("distinct");
				break;
			case EAggregateType.unique:
				this.acceptKeyword("unique");
				break;
			}
			switch (node.FunctionType)
			{
			case EFunctionType.unknown_t:
				if (node.Args != null)
				{
					node.Args.accept(this);
					goto IL_488;
				}
				goto IL_488;
			case EFunctionType.udf_t:
			case EFunctionType.case_n_t:
			case EFunctionType.chr_t:
				if (node.Args != null)
				{
					node.Args.accept(this);
				}
				if (node.WindowDef != null)
				{
					node.WindowDef.accept(this);
					goto IL_488;
				}
				goto IL_488;
			case EFunctionType.trim_t:
				if (node.TrimArgument != null)
				{
					TTrimArgument trimArgument = node.TrimArgument;
					if (trimArgument.Both)
					{
						this.acceptKeyword("both");
					}
					if (trimArgument.Trailing)
					{
						this.acceptKeyword("trailing");
					}
					if (trimArgument.Leading)
					{
						this.acceptKeyword("leading");
					}
					if (trimArgument.TrimCharacter != null)
					{
						trimArgument.TrimCharacter.accept(this);
						this.acceptKeyword("from");
					}
					trimArgument.StringExpression.accept(this);
					goto IL_488;
				}
				goto IL_488;
			case EFunctionType.cast_t:
				node.Expr1.accept(this);
				this.acceptKeyword("as");
				node.Typename.accept(this);
				goto IL_488;
			case EFunctionType.convert_t:
				if (node.Typename != null)
				{
					node.Typename.accept(this);
				}
				if (node.Parameter != null)
				{
					this.acceptSymbol(",");
					node.Parameter.accept(this);
				}
				if (node.Style != null)
				{
					this.acceptSymbol(",");
					node.Style.accept(this);
					goto IL_488;
				}
				goto IL_488;
			case EFunctionType.extract_t:
				if (node.Args != null)
				{
					node.Args.accept(this);
					goto IL_488;
				}
				this.acceptKeyword(node.Extract_time_token.ToString());
				this.acceptKeyword("from");
				if (node.Expr1 != null)
				{
					node.Expr1.accept(this);
					goto IL_488;
				}
				goto IL_488;
			case EFunctionType.treat_t:
				node.Expr1.accept(this);
				node.Typename.accept(this);
				goto IL_488;
			case EFunctionType.contains_t:
				node.Expr1.accept(this);
				node.Expr2.accept(this);
				goto IL_488;
			case EFunctionType.freetext_t:
				node.Expr1.accept(this);
				node.Expr2.accept(this);
				goto IL_488;
			case EFunctionType.position_t:
			case EFunctionType.xmlquery_t:
			case EFunctionType.xmlcast_t:
			case EFunctionType.substring_t:
			case EFunctionType.adddate_t:
			case EFunctionType.date_add_t:
			case EFunctionType.subdate_t:
			case EFunctionType.date_sub_t:
			case EFunctionType.timestampadd_t:
			case EFunctionType.timestampdiff_t:
			case EFunctionType.match_against_t:
			case EFunctionType.range_n_t:
				if (node.Args != null)
				{
					node.Args.accept(this);
					goto IL_488;
				}
				if (node.startToken != null && node.endToken != null)
				{
					TSourceToken tsourceToken = node.startToken;
					int num = 0;
					while (tsourceToken != null)
					{
						if (tsourceToken.Equals(node.endToken))
						{
							break;
						}
						if (tsourceToken.tokencode == 41)
						{
							num--;
						}
						if (num > 0)
						{
							this.acceptToken(tsourceToken);
						}
						if (tsourceToken.tokencode == 40)
						{
							num++;
						}
						tsourceToken = tsourceToken.NextTokenInChain;
					}
					goto IL_488;
				}
				goto IL_488;
			case EFunctionType.translate_t:
				node.Expr1.accept(this);
				this.acceptSymbol(",");
				node.Expr2.accept(this);
				if (node.Expr3 != null)
				{
					this.acceptSymbol(",");
					node.Expr3.accept(this);
					goto IL_488;
				}
				goto IL_488;
			case EFunctionType.group_concat_t:
				node.GroupConcatParam.accept(this);
				goto IL_488;
			}
			if (node.Args != null)
			{
				node.Args.accept(this);
			}
			else if (node.startToken != null && node.endToken != null)
			{
				TSourceToken tsourceToken2 = node.startToken;
				int num2 = 0;
				while (tsourceToken2 != null && !tsourceToken2.Equals(node.endToken))
				{
					if (tsourceToken2.tokencode == 41)
					{
						num2--;
					}
					if (num2 > 0)
					{
						this.acceptToken(tsourceToken2);
					}
					if (tsourceToken2.tokencode == 40)
					{
						num2++;
					}
					tsourceToken2 = tsourceToken2.NextTokenInChain;
				}
			}
			IL_488:
			this.acceptSymbol(")");
			if (node.WindowDef != null)
			{
				node.WindowDef.accept(this);
			}
		}

		// Token: 0x060010BA RID: 4282 RVA: 0x0030D994 File Offset: 0x0030BB94
		public override void preVisit(TGroupConcatParam node)
		{
			if (node.Distinct)
			{
				this.acceptKeyword("DISTINCT");
			}
			this.visitExprList(node.ExprList);
			if (node.OrderBy != null)
			{
				node.OrderBy.accept(this);
			}
			if (node.SeparatorToken != null)
			{
				this.acceptKeyword("SEPARATOR");
				this.acceptToken(node.SeparatorToken);
			}
		}

		// Token: 0x060010BB RID: 4283 RVA: 0x0030D9F4 File Offset: 0x0030BBF4
		public override void preVisit(TExpression node)
		{
			switch (node.ExpressionType)
			{
			case EExpressionType.simple_source_token_t:
				this.acceptIdentifier(node.SourcetokenOperand.ToString());
				return;
			case EExpressionType.simple_object_name_t:
				node.ObjectOperand.accept(this);
				if (node.OracleOuterJoin)
				{
					this.acceptSymbol("(+)", 289);
					return;
				}
				break;
			case EExpressionType.simple_constant_t:
				node.ConstantOperand.accept(this);
				return;
			case EExpressionType.arithmetic_t:
			case EExpressionType.arithmetic_compound_operator_t:
			case EExpressionType.arithmetic_exponentiation_t:
			case EExpressionType.bitwise_t:
			case EExpressionType.boolean_comparison_equal_t:
			case EExpressionType.boolean_comparison_greaterThan_t:
			case EExpressionType.boolean_comparison_lessThan_t:
			case EExpressionType.boolean_comparison_greaterThanOrEqualTo_t:
			case EExpressionType.boolean_comparison_lessThanOrEqualTo_t:
			case EExpressionType.boolean_comparison_notEqualToBrackets_t:
			case EExpressionType.boolean_comparison_notEqualToExclamation_t:
			case EExpressionType.boolean_comparison_notLessThan_t:
			case EExpressionType.boolean_comparison_notGreaterThan_t:
			case EExpressionType.boolean_comparison_leftOuterJoin_t:
			case EExpressionType.boolean_comparison_rightOuterJoin_t:
			case EExpressionType.logical_t:
			case EExpressionType.unary_t:
			case EExpressionType.unary_left_unknown_t:
			case EExpressionType.unary_right_unknown_t:
			case EExpressionType.group_t:
			case EExpressionType.new_variant_type_t:
			case EExpressionType.until_changed_t:
			case EExpressionType.is_document_t:
			case EExpressionType.is_distinct_from_t:
			case EExpressionType.is_unknown_t:
			case EExpressionType.is_false_t:
			case EExpressionType.is_true_t:
			case EExpressionType.arrayaccess_t:
			case EExpressionType.fieldselection_t:
			case EExpressionType.next_value_for_t:
			case EExpressionType.datetime_t:
			case EExpressionType.interval_t:
			case EExpressionType.model_t:
			case EExpressionType.object_access_t:
			case EExpressionType.xml_t:
			case EExpressionType.units_t:
			case EExpressionType.multiset_union_all_t:
			case EExpressionType.array_access_expr_t:
			case EExpressionType.field_access_t:
			case EExpressionType.hive_variable_t:
				break;
			case EExpressionType.arithmetic_plus_t:
			case EExpressionType.arithmetic_minus_t:
			case EExpressionType.arithmetic_times_t:
			case EExpressionType.arithmetic_divide_t:
			case EExpressionType.arithmetic_modulo_t:
			case EExpressionType.concatenate_t:
			case EExpressionType.bitwise_and_t:
			case EExpressionType.bitwise_or_t:
			case EExpressionType.bitwise_xor_t:
			case EExpressionType.bitwise_exclusive_or_t:
			case EExpressionType.bitwise_shift_left_t:
			case EExpressionType.bitwise_shift_right_t:
			case EExpressionType.scope_resolution_t:
			case EExpressionType.exponentiate_t:
			case EExpressionType.logical_and_t:
			case EExpressionType.logical_or_t:
			case EExpressionType.logical_xor_t:
			case EExpressionType.is_t:
			case EExpressionType.range_t:
			case EExpressionType.power_t:
			case EExpressionType.period_ldiff_t:
			case EExpressionType.period_rdiff_t:
			case EExpressionType.period_p_intersect_t:
			case EExpressionType.period_p_normalize_t:
			case EExpressionType.collate_t:
			case EExpressionType.left_join_t:
			case EExpressionType.right_join_t:
			case EExpressionType.ref_arrow_t:
			case EExpressionType.sqlserver_proprietary_column_alias_t:
			case EExpressionType.left_shift_t:
			case EExpressionType.right_shift_t:
			case EExpressionType.member_of_t:
			case EExpressionType.multiset_union_t:
			case EExpressionType.multiset_union_distinct_t:
			case EExpressionType.multiset_intersect_t:
			case EExpressionType.multiset_intersect_distinct_t:
			case EExpressionType.multiset_except_t:
			case EExpressionType.multiset_except_distinct_t:
			case EExpressionType.json_get_text:
			case EExpressionType.json_get_text_at_path:
			case EExpressionType.json_get_object:
			case EExpressionType.json_get_object_at_path:
			case EExpressionType.json_left_contain:
			case EExpressionType.json_right_contain:
			case EExpressionType.json_exist:
			case EExpressionType.json_any_exist:
			case EExpressionType.json_all_exist:
			case EExpressionType.contains_t:
				node.LeftOperand.accept(this);
				this.scriptWriter.addBinaryOperator(node.ExpressionType);
				node.RightOperand.accept(this);
				return;
			case EExpressionType.parenthesis_t:
				this.acceptSymbol("(");
				node.LeftOperand.accept(this);
				this.acceptSymbol(")");
				return;
			case EExpressionType.assignment_t:
				node.LeftOperand.accept(this);
				this.acceptSymbol("=");
				node.RightOperand.accept(this);
				return;
			case EExpressionType.list_t:
			case EExpressionType.collection_constructor_set_t:
			case EExpressionType.collection_constructor_multiset_t:
			case EExpressionType.collection_constructor_list_t:
				if (node.ExprList != null)
				{
					this.acceptSymbol("(");
					this.visitExprList(node.ExprList);
					this.acceptSymbol(")");
					return;
				}
				break;
			case EExpressionType.simple_comparison_t:
				if (node.SubQuery != null)
				{
					node.ExprList.accept(this);
					this.scriptWriter.addComparisonOperator(node.ComparisonType);
					node.SubQuery.accept(this);
					return;
				}
				node.LeftOperand.accept(this);
				this.scriptWriter.addComparisonOperator(node.ComparisonType);
				node.RightOperand.accept(this);
				return;
			case EExpressionType.group_comparison_t:
				if (node.ExprList != null)
				{
					node.ExprList.accept(this);
				}
				else
				{
					node.LeftOperand.accept(this);
				}
				this.scriptWriter.addComparisonOperator(node.ComparisonType);
				if (node.QuantifierType != EQuantifierType.none)
				{
					switch (node.QuantifierType)
					{
					case EQuantifierType.all:
						this.acceptKeyword("all");
						break;
					case EQuantifierType.some:
						this.acceptKeyword("some");
						break;
					case EQuantifierType.any:
						this.acceptKeyword("any");
						break;
					}
				}
				node.RightOperand.accept(this);
				return;
			case EExpressionType.unary_plus_t:
			case EExpressionType.unary_minus_t:
			case EExpressionType.unary_prior_t:
			case EExpressionType.unary_connect_by_root_t:
			case EExpressionType.unary_squareroot_t:
			case EExpressionType.unary_cuberoot_t:
			case EExpressionType.unary_factorialprefix_t:
			case EExpressionType.unary_absolutevalue_t:
			case EExpressionType.unary_bitwise_not_t:
			case EExpressionType.unary_binary_operator_t:
				this.scriptWriter.addUnaryOperator(node.ExpressionType);
				node.RightOperand.accept(this);
				return;
			case EExpressionType.unary_factorial_t:
			case EExpressionType.floating_point_t:
			case EExpressionType.day_to_second_t:
			case EExpressionType.year_to_month_t:
			case EExpressionType.typecast_t:
				node.LeftOperand.accept(this);
				return;
			case EExpressionType.case_t:
				node.CaseExpression.accept(this);
				return;
			case EExpressionType.function_t:
			case EExpressionType.new_structured_type_t:
				node.FunctionCall.accept(this);
				return;
			case EExpressionType.cursor_t:
				this.acceptKeyword("cursor");
				node.SubQuery.accept(this);
				return;
			case EExpressionType.subquery_t:
				node.SubQuery.accept(this);
				return;
			case EExpressionType.null_t:
				node.LeftOperand.accept(this);
				this.acceptKeyword("is");
				if (node.NotOperator)
				{
					this.acceptKeyword("not");
				}
				this.acceptKeyword("null");
				return;
			case EExpressionType.between_t:
				node.BetweenOperand.accept(this);
				if (node.NotOperator)
				{
					this.acceptKeyword("not");
				}
				this.acceptKeyword("between");
				node.LeftOperand.accept(this);
				this.acceptKeyword("and");
				node.RightOperand.accept(this);
				return;
			case EExpressionType.exists_t:
				this.acceptKeyword("exists");
				node.SubQuery.accept(this);
				return;
			case EExpressionType.pattern_matching_t:
				node.LeftOperand.accept(this);
				if (node.NotOperator)
				{
					this.acceptKeyword("not");
				}
				this.acceptKeyword("like");
				node.RightOperand.accept(this);
				if (node.LikeEscapeOperand != null)
				{
					this.acceptKeyword("escape");
					node.LikeEscapeOperand.accept(this);
					return;
				}
				break;
			case EExpressionType.place_holder_t:
				this.acceptLiteral(node.String);
				break;
			case EExpressionType.logical_not_t:
				this.acceptKeyword("not");
				node.RightOperand.accept(this);
				return;
			case EExpressionType.in_t:
				if (node.ExprList != null)
				{
					this.acceptSymbol("(");
					this.visitExprList(node.ExprList);
					this.acceptSymbol(")");
				}
				else
				{
					node.LeftOperand.accept(this);
				}
				if (node.NotOperator)
				{
					this.acceptKeyword("not");
				}
				this.acceptKeyword("in");
				node.RightOperand.accept(this);
				return;
			case EExpressionType.is_of_type_t:
				this.visitNodeByToken(node);
				return;
			case EExpressionType.at_time_zone_t:
				node.LeftOperand.accept(this);
				this.acceptKeyword("at");
				this.acceptKeyword("time");
				this.acceptKeyword("zone");
				node.RightOperand.accept(this);
				return;
			case EExpressionType.at_local_t:
				node.LeftOperand.accept(this);
				this.acceptKeyword("at");
				this.acceptKeyword("local");
				return;
			case EExpressionType.multiset_t:
				this.acceptKeyword("MULTISET");
				node.SubQuery.accept(this);
				return;
			case EExpressionType.array_constructor_t:
				if (node.SubQuery != null)
				{
					node.SubQuery.accept(this);
				}
				if (node.ExprList != null)
				{
					node.ExprList.accept(this);
					return;
				}
				break;
			case EExpressionType.row_constructor_t:
				if (node.ExprList != null)
				{
					node.ExprList.accept(this);
					return;
				}
				break;
			case EExpressionType.type_constructor_t:
				this.acceptKeyword("new");
				node.FunctionCall.accept(this);
				return;
			default:
				return;
			}
		}

		// Token: 0x060010BC RID: 4284 RVA: 0x0030E0AC File Offset: 0x0030C2AC
		public override void preVisit(TSelectSqlStatement node)
		{
			for (int i = 0; i < node.ParenthesisCount; i++)
			{
				this.acceptSymbol("(");
			}
			for (int j = 0; j < node.ParenthesisCountBeforeOrder; j++)
			{
				this.acceptSymbol("(");
			}
			if (node.CteList != null)
			{
				this.acceptKeyword("with");
				this.visitCTEList(node.CteList);
			}
			if (node.CombinedQuery)
			{
				this.acceptNewline();
				node.LeftStmt.accept(this);
				this.acceptNewline();
				this.acceptKeyword(node.SetOperatorType.ToString());
				if (node.All)
				{
					this.acceptKeyword("all");
				}
				this.acceptNewline();
				node.RightStmt.accept(this);
				for (int k = 0; k < node.ParenthesisCountBeforeOrder; k++)
				{
					this.acceptSymbol(")");
				}
				if (node.OrderbyClause != null)
				{
					this.acceptNewline();
					node.OrderbyClause.accept(this);
				}
				if (node.LimitClause != null)
				{
					node.LimitClause.accept(this);
				}
				if (node.ForUpdateClause != null)
				{
					node.ForUpdateClause.accept(this);
				}
				if (node.ComputeClause != null)
				{
					node.ComputeClause.accept(this);
				}
				for (int l = 0; l < node.ParenthesisCount; l++)
				{
					this.acceptSymbol(")");
				}
				return;
			}
			if (node.ValueClause != null)
			{
				return;
			}
			this.acceptKeyword("select");
			if (node.OracleHint != null && node.OracleHint.Length > 0)
			{
				this.acceptOracleHint(node.OracleHint);
			}
			if (node.SelectDistinct != null)
			{
				switch (node.SelectDistinct.DistinctType)
				{
				case 1:
					this.acceptKeyword("distinct");
					break;
				case 2:
					this.acceptKeyword("distinct");
					this.acceptKeyword("on");
					break;
				case 3:
					this.acceptKeyword("all");
					break;
				case 4:
					this.acceptKeyword("unique");
					break;
				case 5:
					this.acceptKeyword("distinctrow");
					break;
				}
			}
			if (node.TopClause != null)
			{
				node.TopClause.accept(this);
			}
			if (node.ResultColumnList != null)
			{
				this.acceptNewline();
				this.visitResultColumnList(node.ResultColumnList);
			}
			if (node.IntoClause != null)
			{
				this.acceptNewline();
				node.IntoClause.accept(this);
			}
			if (node.joins.Count > 0)
			{
				this.acceptNewline();
				this.acceptKeyword("from");
				this.visitJoinList(node.joins);
			}
			if (node.WhereClause != null)
			{
				this.acceptNewline();
				node.WhereClause.accept(this);
			}
			if (node.HierarchicalClause != null)
			{
				this.acceptNewline();
				node.HierarchicalClause.accept(this);
			}
			if (node.GroupByClause != null)
			{
				this.acceptNewline();
				node.GroupByClause.accept(this);
			}
			if (node.QualifyClause != null)
			{
				node.QualifyClause.accept(this);
			}
			for (int m = 0; m < node.ParenthesisCountBeforeOrder; m++)
			{
				this.acceptSymbol(")");
			}
			if (node.OrderbyClause != null)
			{
				this.acceptNewline();
				node.OrderbyClause.accept(this);
			}
			if (node.LimitClause != null)
			{
				node.LimitClause.accept(this);
			}
			if (node.ForUpdateClause != null)
			{
				node.ForUpdateClause.accept(this);
			}
			if (node.ComputeClause != null)
			{
				node.ComputeClause.accept(this);
			}
			if (node.OffsetClause != null)
			{
				this.acceptNewline();
				node.OffsetClause.accept(this);
			}
			if (node.FetchFirstClause != null)
			{
				this.acceptNewline();
				node.FetchFirstClause.accept(this);
			}
			if (node.OptionClause != null)
			{
				this.acceptNewline();
				this.visitNodeByToken(node.OptionClause);
			}
			if (node.IsolationClause != null)
			{
				node.IsolationClause.accept(this);
			}
			for (int n = 0; n < node.ParenthesisCount; n++)
			{
				this.acceptSymbol(")");
			}
		}

		// Token: 0x060010BD RID: 4285 RVA: 0x0030E486 File Offset: 0x0030C686
		public override void preVisit(TOffsetClause node)
		{
			this.acceptKeyword("offset");
			if (node.SelectOffsetValue != null)
			{
				node.SelectOffsetValue.accept(this);
			}
			this.acceptKeyword(node.rowToken);
			this.acceptKeyword(node.rowsToken);
		}

		// Token: 0x060010BE RID: 4286 RVA: 0x0030E4C0 File Offset: 0x0030C6C0
		public override void preVisit(TFetchFirstClause node)
		{
			this.acceptKeyword("fetch");
			this.acceptKeyword(node.firstToken);
			this.acceptKeyword(node.nextToken);
			if (node.FetchValue != null)
			{
				node.FetchValue.accept(this);
				this.acceptKeyword(node.percentToken);
			}
			this.acceptKeyword(node.rowToken);
			this.acceptKeyword(node.rowsToken);
			this.acceptKeyword(node.onlyToken);
			if (node.tiesToken != null)
			{
				this.acceptKeyword("with");
				this.acceptKeyword("ties");
			}
		}

		// Token: 0x060010BF RID: 4287 RVA: 0x0030E554 File Offset: 0x0030C754
		public override void preVisit(TCreateViewSqlStatement stmt)
		{
			if (stmt.CteList != null)
			{
				this.acceptKeyword("with");
				this.visitCTEList(stmt.CteList);
			}
			this.acceptKeyword("create");
			if (stmt.StReplace != null)
			{
				this.acceptKeyword("or");
				this.acceptKeyword("replace");
			}
			if (stmt.StForce != null)
			{
				this.acceptKeyword("force");
			}
			this.acceptKeyword("view");
			stmt.ViewName.accept(this);
			if (stmt.ViewAliasClause != null)
			{
				stmt.ViewAliasClause.accept(this);
			}
			this.acceptNewline();
			this.acceptKeyword("as");
			this.acceptNewline();
			if (stmt.Subquery != null)
			{
				stmt.Subquery.accept(this);
			}
			if (stmt.RestrictionClause != null)
			{
				this.acceptNewline();
				stmt.RestrictionClause.accept(this);
			}
		}

		// Token: 0x060010C0 RID: 4288 RVA: 0x0030E62C File Offset: 0x0030C82C
		public override void preVisit(TRestrictionClause clause)
		{
			if (clause.Type == 2)
			{
				this.acceptKeyword("with");
				this.acceptKeyword("check");
				this.acceptKeyword("option");
			}
			else if (clause.Type == 1)
			{
				this.acceptKeyword("with");
				this.acceptKeyword("read");
				this.acceptKeyword("only");
			}
			else if (clause.Type == 3)
			{
				this.acceptKeyword("with");
				this.acceptKeyword("local");
				this.acceptKeyword("check");
				this.acceptKeyword("option");
			}
			else if (clause.Type == 4)
			{
				this.acceptKeyword("with");
				this.acceptKeyword("cascaded");
				this.acceptKeyword("check");
				this.acceptKeyword("option");
			}
			if (clause.ConstraintName != null)
			{
				clause.ConstraintName.accept(this);
			}
		}

		// Token: 0x060010C1 RID: 4289 RVA: 0x0030E714 File Offset: 0x0030C914
		public override void preVisit(TViewAliasClause clause)
		{
			this.acceptSymbol("(");
			this.visitViewAliasItemList(clause.ViewAliasItemList);
			this.acceptSymbol(")");
		}

		// Token: 0x060010C2 RID: 4290 RVA: 0x0030E738 File Offset: 0x0030C938
		internal virtual void visitViewAliasItemList(TViewAliasItemList viewAliasItemList)
		{
			for (int i = 0; i < viewAliasItemList.Count; i++)
			{
				TViewAliasItem viewAliasItem = viewAliasItemList.getViewAliasItem(i);
				this.visitViewAliasItem(viewAliasItem);
				if (i != viewAliasItemList.Count - 1)
				{
					this.acceptSymbol(",");
				}
			}
		}

		// Token: 0x060010C3 RID: 4291 RVA: 0x0030E77B File Offset: 0x0030C97B
		private void visitViewAliasItem(TViewAliasItem aliasItem)
		{
			aliasItem.Alias.accept(this);
		}

		// Token: 0x060010C4 RID: 4292 RVA: 0x0030E789 File Offset: 0x0030C989
		public override void preVisit(TResultColumn node)
		{
			node.Expr.accept(this);
			if (node.AliasClause != null)
			{
				this.acceptSpace(1);
				node.AliasClause.accept(this);
			}
		}

		// Token: 0x060010C5 RID: 4293 RVA: 0x0030E7B4 File Offset: 0x0030C9B4
		public override void preVisit(TColumnDefinitionList node)
		{
			for (int i = 0; i < node.Count; i++)
			{
				node.getColumn(i).accept(this);
				if (i != node.Count - 1)
				{
					this.acceptSymbol(",");
				}
			}
		}

		// Token: 0x060010C6 RID: 4294 RVA: 0x0030E7F8 File Offset: 0x0030C9F8
		public override void preVisit(TObjectNameList node)
		{
			for (int i = 0; i < node.Count; i++)
			{
				node.getObjectName(i).accept(this);
				if (i != node.Count - 1)
				{
					this.acceptSymbol(",");
				}
			}
		}

		// Token: 0x060010C7 RID: 4295 RVA: 0x0030E83C File Offset: 0x0030CA3C
		public override void preVisit(TConstraintList node)
		{
			for (int i = 0; i < node.Count; i++)
			{
				node.getConstraint(i).accept(this);
				if (i != node.Count - 1)
				{
					this.acceptSymbol(",");
				}
			}
		}

		// Token: 0x060010C8 RID: 4296 RVA: 0x0030E880 File Offset: 0x0030CA80
		public override void preVisit(TParameterDeclarationList @params)
		{
			for (int i = 0; i < @params.Count; i++)
			{
				@params.getParameterDeclarationItem(i).accept(this);
				if (i != @params.Count - 1)
				{
					this.acceptSymbol(",");
				}
			}
		}

		// Token: 0x060010C9 RID: 4297 RVA: 0x0030E8C1 File Offset: 0x0030CAC1
		public override void preVisit(TParameterDeclaration param)
		{
			if (param.ParameterName != null)
			{
				param.ParameterName.accept(this);
			}
			if (param.DataType != null)
			{
				param.DataType.accept(this);
			}
		}

		// Token: 0x060010CA RID: 4298 RVA: 0x0030E8EC File Offset: 0x0030CAEC
		public override void preVisit(TMssqlCreateFunction function)
		{
			this.acceptKeyword("create");
			this.acceptKeyword("function");
			if (function.FunctionName != null)
			{
				function.FunctionName.accept(this);
			}
			if (function.ParameterDeclarations != null && function.ParameterDeclarations.Count > 0)
			{
				this.acceptSymbol("(");
				function.ParameterDeclarations.accept(this);
				this.acceptSymbol(")");
			}
			if (function.ReturnDataType != null)
			{
				this.acceptNewline();
				this.acceptSpace(4);
				this.acceptKeyword("returns");
				function.ReturnDataType.accept(this);
			}
			this.acceptNewline();
			this.acceptKeyword("as");
			this.acceptNewline();
			if (function.BodyStatements != null)
			{
				function.BodyStatements.accept(this);
				this.acceptSymbol(";");
			}
		}

		// Token: 0x060010CB RID: 4299 RVA: 0x0030E9C0 File Offset: 0x0030CBC0
		public override void preVisit(TMssqlCreateTrigger trigger)
		{
			if (trigger.AlterTrigger)
			{
				this.acceptKeyword("alter");
			}
			else
			{
				this.acceptKeyword("create");
			}
			this.acceptKeyword("trigger");
			if (trigger.TriggerName != null)
			{
				trigger.TriggerName.accept(this);
			}
			if (trigger.OnTable != null)
			{
				this.acceptNewline();
				this.acceptSpace(4);
				this.acceptKeyword("on");
				trigger.OnTable.accept(this);
			}
			this.acceptNewline();
			if (trigger.TimingPoint == ETriggerTimingPoint.ttpFor)
			{
				this.acceptKeyword("for");
			}
			if (trigger.TimingPoint == ETriggerTimingPoint.ttpTinsteadOf)
			{
				this.acceptKeyword("instead");
				this.acceptKeyword("of");
			}
			if (trigger.TimingPoint == ETriggerTimingPoint.ttpAfter)
			{
				this.acceptKeyword("after");
			}
			if (trigger.TimingPoint == ETriggerTimingPoint.ttpBefore)
			{
				this.acceptKeyword("before");
			}
			if (trigger.DmlTypes != ETriggerDmlType.tdtNone)
			{
				int num = 1;
				if ((trigger.DmlTypes & ETriggerDmlType.tdtDelete) != ETriggerDmlType.tdtNone)
				{
					if (num++ > 1)
					{
						this.acceptSymbol(",");
					}
					this.acceptKeyword("delete");
				}
				if ((trigger.DmlTypes & ETriggerDmlType.tdtInsert) != ETriggerDmlType.tdtNone)
				{
					if (num++ > 1)
					{
						this.acceptSymbol(",");
					}
					this.acceptKeyword("insert");
				}
				if ((trigger.DmlTypes & ETriggerDmlType.tdtUpdate) != ETriggerDmlType.tdtNone)
				{
					if (num++ > 1)
					{
						this.acceptSymbol(",");
					}
					this.acceptKeyword("update");
				}
			}
			this.acceptNewline();
			this.acceptKeyword("as");
			this.acceptNewline();
			if (trigger.BodyStatements != null)
			{
				trigger.BodyStatements.accept(this);
			}
		}

		// Token: 0x060010CC RID: 4300 RVA: 0x0030EB48 File Offset: 0x0030CD48
		public override void preVisit(TProcedureOption option)
		{
			if (option.OptionType == EProcedureOptionType.potExecuteAs)
			{
				this.acceptKeyword("execute");
				this.acceptKeyword("as");
				this.acceptKeyword("caller");
			}
			if (option.OptionType == EProcedureOptionType.potCalledOnNullInput)
			{
				this.acceptKeyword("called");
				this.acceptKeyword("on");
				this.acceptKeyword("null");
				this.acceptKeyword("input");
			}
			if (option.OptionType == EProcedureOptionType.potEncryption)
			{
				this.acceptKeyword("encryption");
			}
			if (option.OptionType == EProcedureOptionType.potNativeCompilation)
			{
				this.acceptKeyword("native");
				this.acceptKeyword("compilation");
			}
			if (option.OptionType == EProcedureOptionType.potRecompile)
			{
				this.acceptKeyword("recompile");
			}
			if (option.OptionType == EProcedureOptionType.potReturnsNullOnNullInput)
			{
				this.acceptKeyword("returns");
				this.acceptKeyword("null");
				this.acceptKeyword("on");
				this.acceptKeyword("null");
				this.acceptKeyword("input");
			}
			if (option.OptionType == EProcedureOptionType.potSchemaBinding)
			{
				this.acceptKeyword("schema");
				this.acceptKeyword("binding");
			}
		}

		// Token: 0x060010CD RID: 4301 RVA: 0x0030EC5C File Offset: 0x0030CE5C
		public override void preVisit(TMssqlCreateProcedure procedure)
		{
			this.acceptKeyword("create");
			this.acceptKeyword("procedure");
			if (procedure.ProcedureName != null)
			{
				procedure.ProcedureName.accept(this);
			}
			this.acceptNewline();
			this.acceptSpace(4);
			if (procedure.ParameterDeclarations != null && procedure.DeclareStatements.Count > 0)
			{
				procedure.ParameterDeclarations.accept(this);
			}
			if (procedure.ProcedureOptions != null && procedure.ProcedureOptions.Count > 0)
			{
				this.acceptKeyword("with");
				for (int i = 0; i < procedure.ProcedureOptions.Count; i++)
				{
					procedure.ProcedureOptions[i].accept(this);
					if (i != procedure.ProcedureOptions.Count - 1)
					{
						this.acceptSymbol(",");
					}
				}
			}
			if (procedure.ForReplication)
			{
				this.acceptKeyword("for");
				this.acceptKeyword("replication");
			}
			this.acceptNewline();
			this.acceptKeyword("as");
			this.acceptNewline();
			if (procedure.BodyStatements != null)
			{
				procedure.BodyStatements.accept(this);
			}
		}

		// Token: 0x060010CE RID: 4302 RVA: 0x0030ED70 File Offset: 0x0030CF70
		public override void preVisit(TMssqlFetch stmt)
		{
			this.acceptKeyword("fetch");
			this.acceptKeyword("from");
			if (stmt.CursorName != null)
			{
				stmt.CursorName.accept(this);
			}
			this.acceptKeyword("into");
			if (stmt.VariableNames != null)
			{
				stmt.VariableNames.accept(this);
			}
		}

		// Token: 0x060010CF RID: 4303 RVA: 0x0030EDC8 File Offset: 0x0030CFC8
		public override void preVisit(TMssqlBlock block)
		{
			this.acceptKeyword("begin");
			this.acceptNewline();
			if (block.BodyStatements != null)
			{
				block.BodyStatements.accept(this);
				this.acceptSymbol(";");
				this.acceptNewline();
			}
			this.acceptKeyword("end");
		}

		// Token: 0x060010D0 RID: 4304 RVA: 0x0030EE16 File Offset: 0x0030D016
		public override void preVisit(TMssqlRollback rollback)
		{
			this.acceptKeyword("rollback");
			if (rollback.Trans_or_work != null)
			{
				this.acceptToken(rollback.Trans_or_work);
			}
			if (rollback.TransactionName != null)
			{
				rollback.TransactionName.accept(this);
			}
		}

		// Token: 0x060010D1 RID: 4305 RVA: 0x0030EE4C File Offset: 0x0030D04C
		public override void preVisit(TMssqlRaiserror raiseError)
		{
			this.acceptKeyword("raiserror");
			this.acceptSymbol("(");
			if (raiseError.MessageText != null)
			{
				raiseError.MessageText.accept(this);
			}
			if (raiseError.Severity != null)
			{
				this.acceptSymbol(",");
				raiseError.Severity.accept(this);
			}
			if (raiseError.State != null)
			{
				this.acceptSymbol(",");
				raiseError.State.accept(this);
			}
			if (raiseError.Args != null && raiseError.Args.Count > 0)
			{
				for (int i = 0; i < raiseError.Args.Count; i++)
				{
					this.acceptSymbol(",");
					raiseError.Args.getExpression(i).accept(this);
				}
			}
			this.acceptSymbol(")");
		}

		// Token: 0x060010D2 RID: 4306 RVA: 0x0030EF15 File Offset: 0x0030D115
		public override void preVisit(TMssqlPrint stmt)
		{
			this.acceptKeyword("print");
			if (stmt.Messages != null)
			{
				stmt.Messages.accept(this);
			}
		}

		// Token: 0x060010D3 RID: 4307 RVA: 0x0030EF38 File Offset: 0x0030D138
		public override void preVisit(TMssqlDeclare stmt)
		{
			this.acceptKeyword("declare");
			if (stmt.Variables != null)
			{
				stmt.Variables.accept(this);
			}
			if (stmt.CursorName != null)
			{
				stmt.CursorName.accept(this);
				this.acceptKeyword("cursor");
				if (stmt.Subquery != null)
				{
					this.acceptKeyword("for");
					stmt.Subquery.accept(this);
				}
			}
		}

		// Token: 0x060010D4 RID: 4308 RVA: 0x0030EFA4 File Offset: 0x0030D1A4
		public override void preVisit(TVarDeclStmt stmt)
		{
			if (stmt.ElementName != null)
			{
				stmt.ElementName.accept(this);
			}
			if (stmt.DataType != null)
			{
				stmt.DataType.accept(this);
			}
			if (stmt.DefaultValue != null)
			{
				if (stmt.DeclareType == EDeclareType.variable)
				{
					this.acceptKeyword("default");
					stmt.DefaultValue.accept(this);
					return;
				}
				if (stmt.DeclareType == EDeclareType.constant)
				{
					this.acceptSymbol(":=");
					stmt.DefaultValue.accept(this);
				}
			}
		}

		// Token: 0x060010D5 RID: 4309 RVA: 0x0030F022 File Offset: 0x0030D222
		public override void preVisit(TMssqlSet stmt)
		{
			this.acceptKeyword("set");
			if (stmt.VarName != null)
			{
				stmt.VarName.accept(this);
				this.acceptSymbol("=");
			}
			if (stmt.VarExpr != null)
			{
				stmt.VarExpr.accept(this);
			}
		}

		// Token: 0x060010D6 RID: 4310 RVA: 0x0030F062 File Offset: 0x0030D262
		public override void preVisit(TMssqlReturn stmt)
		{
			this.acceptKeyword("return");
			if (stmt.ReturnExpr != null)
			{
				stmt.ReturnExpr.accept(this);
			}
		}

		// Token: 0x060010D7 RID: 4311 RVA: 0x0030F083 File Offset: 0x0030D283
		public override void preVisit(TMssqlLabel stmt)
		{
			base.preVisit(stmt);
		}

		// Token: 0x060010D8 RID: 4312 RVA: 0x0030F08C File Offset: 0x0030D28C
		public override void preVisit(TDeclareVariableList variables)
		{
			for (int i = 0; i < variables.Count; i++)
			{
				variables.getDeclareVariable(i).accept(this);
				if (i != variables.Count - 1)
				{
					this.acceptSymbol(",");
				}
			}
		}

		// Token: 0x060010D9 RID: 4313 RVA: 0x0030F0CD File Offset: 0x0030D2CD
		public override void preVisit(TDeclareVariable variable)
		{
			if (variable.VariableName != null)
			{
				variable.VariableName.accept(this);
			}
			if (variable.Datatype != null)
			{
				variable.Datatype.accept(this);
			}
		}

		// Token: 0x060010DA RID: 4314 RVA: 0x0030F0F8 File Offset: 0x0030D2F8
		public override void preVisit(TMssqlExecute stmt)
		{
			this.acceptKeyword("exec");
			if (stmt.ModuleName != null)
			{
				stmt.ModuleName.accept(this);
			}
			if (stmt.Parameters != null && stmt.Parameters.Count > 0)
			{
				this.acceptSpace(1);
				stmt.Parameters.accept(this);
			}
		}

		// Token: 0x060010DB RID: 4315 RVA: 0x0030F150 File Offset: 0x0030D350
		public override void preVisit(TMssqlExecuteAs stmt)
		{
			this.acceptKeyword("execute");
			this.acceptKeyword("as");
			switch (stmt.ExecuteAsOption)
			{
			case EExecuteAsOption.eaoCaller:
				this.acceptKeyword("caller");
				break;
			case EExecuteAsOption.eaoSelf:
				this.acceptKeyword("self");
				break;
			case EExecuteAsOption.eaoOwner:
				this.acceptKeyword("owner");
				break;
			case EExecuteAsOption.eaoString:
				this.acceptKeyword("string");
				break;
			case EExecuteAsOption.eaoLogin:
				this.acceptKeyword("login");
				break;
			case EExecuteAsOption.eaoUser:
				this.acceptKeyword("user");
				break;
			}
			if (stmt.loginName != null)
			{
				stmt.loginName.accept(this);
			}
		}

		// Token: 0x060010DC RID: 4316 RVA: 0x0030F1FC File Offset: 0x0030D3FC
		public override void preVisit(TMssqlRevert stmt)
		{
			this.acceptKeyword("revert");
			if (stmt.Cookie != null)
			{
				this.acceptKeyword("with");
				this.acceptIdentifier("cookie");
				this.acceptSymbol("=");
				stmt.Cookie.accept(this);
			}
		}

		// Token: 0x060010DD RID: 4317 RVA: 0x0030F249 File Offset: 0x0030D449
		public override void preVisit(TMssqlStmtStub stmt)
		{
			base.preVisit(stmt);
		}

		// Token: 0x060010DE RID: 4318 RVA: 0x0030F252 File Offset: 0x0030D452
		public override void preVisit(TExecParameter param)
		{
			if (param.ParameterName != null)
			{
				param.ParameterName.accept(this);
			}
			if (param.ParameterValue != null)
			{
				param.ParameterValue.accept(this);
			}
		}

		// Token: 0x060010DF RID: 4319 RVA: 0x0030F27C File Offset: 0x0030D47C
		public override void preVisit(TExecParameterList @params)
		{
			for (int i = 0; i < @params.Count; i++)
			{
				@params.getExecParameter(i).accept(this);
				if (i != @params.Count - 1)
				{
					this.acceptSymbol(",");
				}
			}
		}

		// Token: 0x060010E0 RID: 4320 RVA: 0x0030F2C0 File Offset: 0x0030D4C0
		public override void preVisit(TAlterTableOption node)
		{
			switch (node.OptionType)
			{
			case EAlterTableOptionType.AddColumn:
				this.acceptKeyword("add");
				if (node.ColumnDefinitionList.Count > 1)
				{
					this.acceptSymbol("(");
				}
				node.ColumnDefinitionList.accept(this);
				if (node.ColumnDefinitionList.Count > 1)
				{
					this.acceptSymbol(")");
					return;
				}
				break;
			case EAlterTableOptionType.ModifyColumn:
				this.acceptKeyword("modify");
				this.acceptKeyword("column");
				if (node.ColumnDefinitionList.Count > 1)
				{
					this.acceptSymbol("(");
				}
				node.ColumnDefinitionList.accept(this);
				if (node.ColumnDefinitionList.Count > 1)
				{
					this.acceptSymbol(")");
					return;
				}
				break;
			case EAlterTableOptionType.AlterColumn:
				this.acceptKeyword("alter");
				this.acceptKeyword("column");
				node.ColumnName.accept(this);
				return;
			case EAlterTableOptionType.DropColumn:
				this.acceptKeyword("drop");
				this.acceptKeyword("column");
				if (node.ColumnNameList.Count > 1)
				{
					this.acceptSymbol("(");
				}
				node.ColumnNameList.accept(this);
				if (node.ColumnNameList.Count > 1)
				{
					this.acceptSymbol(")");
					return;
				}
				break;
			case EAlterTableOptionType.SetUnUsedColumn:
			case EAlterTableOptionType.DropUnUsedColumn:
			case EAlterTableOptionType.DropColumnsContinue:
			case EAlterTableOptionType.RenameTable:
				break;
			case EAlterTableOptionType.RenameColumn:
				this.acceptKeyword("rename");
				this.acceptKeyword("column");
				node.ColumnName.accept(this);
				this.acceptKeyword("to");
				node.NewColumnName.accept(this);
				return;
			case EAlterTableOptionType.ChangeColumn:
				this.acceptKeyword("change");
				node.ColumnName.accept(this);
				return;
			case EAlterTableOptionType.AddConstraint:
				this.acceptKeyword("add");
				node.ConstraintList.accept(this);
				break;
			default:
				return;
			}
		}

		// Token: 0x060010E1 RID: 4321 RVA: 0x0030F490 File Offset: 0x0030D690
		public override void preVisit(TAlterTableStatement stmt)
		{
			this.acceptKeyword("alter");
			this.acceptKeyword("table");
			stmt.TableName.accept(this);
			this.acceptNewline();
			if (stmt.AlterTableOptionList != null)
			{
				for (int i = 0; i < stmt.AlterTableOptionList.Count; i++)
				{
					stmt.AlterTableOptionList.getAlterTableOption(i).accept(this);
					if (i != stmt.AlterTableOptionList.Count - 1)
					{
						this.acceptSymbol(",");
						this.acceptNewline();
					}
				}
			}
		}

		// Token: 0x060010E2 RID: 4322 RVA: 0x0030F518 File Offset: 0x0030D718
		public override void preVisit(TStatementList stmts)
		{
			for (int i = 0; i < stmts.Count; i++)
			{
				TCustomSqlStatement stmt = stmts.get(i);
				this.preVisitCustomSqlStatement(stmt);
				if (stmts.Count > 1)
				{
					this.acceptSemicolon();
				}
				if (i != stmts.Count - 1)
				{
					this.acceptNewline();
				}
			}
		}

		// Token: 0x060010E3 RID: 4323 RVA: 0x0030F568 File Offset: 0x0030D768
		protected virtual void preVisitCustomSqlStatement(TCustomSqlStatement stmt)
		{
			if (stmt is TAssignStmt)
			{
				this.preVisit((TAssignStmt)stmt);
				return;
			}
			if (stmt is TElsifStmt)
			{
				this.preVisit((TElsifStmt)stmt);
				return;
			}
			if (stmt is TMssqlRaiserror)
			{
				this.preVisit((TMssqlRaiserror)stmt);
				return;
			}
			if (stmt is TMssqlBlock)
			{
				this.preVisit((TMssqlBlock)stmt);
				return;
			}
			if (stmt is TMssqlExecute)
			{
				this.preVisit((TMssqlExecute)stmt);
				return;
			}
			if (stmt is TMssqlExecuteAs)
			{
				this.preVisit((TMssqlExecuteAs)stmt);
				return;
			}
			if (stmt is TMssqlRevert)
			{
				this.preVisit((TMssqlRevert)stmt);
				return;
			}
			if (stmt is TMssqlStmtStub)
			{
				this.preVisit((TMssqlStmtStub)stmt);
				return;
			}
			if (stmt is TMssqlDeclare)
			{
				this.preVisit((TMssqlDeclare)stmt);
				return;
			}
			if (stmt is TMssqlIfElse)
			{
				this.preVisit((TMssqlIfElse)stmt);
				return;
			}
			if (stmt is TMssqlReturn)
			{
				this.preVisit((TMssqlReturn)stmt);
				return;
			}
			if (stmt is TMssqlLabel)
			{
				this.preVisit((TMssqlLabel)stmt);
				return;
			}
			if (stmt is TMssqlStmtStub)
			{
				this.preVisit((TMssqlStmtStub)stmt);
				return;
			}
			if (stmt is TMssqlPrint)
			{
				this.preVisit((TMssqlPrint)stmt);
				return;
			}
			if (stmt is TSelectSqlStatement)
			{
				this.preVisit((TSelectSqlStatement)stmt);
				return;
			}
			if (stmt is TUpdateSqlStatement)
			{
				this.preVisit((TUpdateSqlStatement)stmt);
				return;
			}
			if (stmt is TInsertSqlStatement)
			{
				this.preVisit((TInsertSqlStatement)stmt);
				return;
			}
			if (stmt is TDeleteSqlStatement)
			{
				this.preVisit((TInsertSqlStatement)stmt);
				return;
			}
			if (stmt is TMergeSqlStatement)
			{
				this.preVisit((TMergeSqlStatement)stmt);
				return;
			}
			if (stmt is TVarDeclStmt)
			{
				this.preVisit((TVarDeclStmt)stmt);
				return;
			}
			if (stmt is TMssqlRollback)
			{
				this.preVisit((TMssqlRollback)stmt);
				return;
			}
			if (stmt is TMssqlRollback)
			{
				this.preVisit((TMssqlRollback)stmt);
				return;
			}
			if (stmt is TDropIndexSqlStatement)
			{
				this.preVisit((TDropIndexSqlStatement)stmt);
				return;
			}
			if (stmt is TMssqlSet)
			{
				this.preVisit((TMssqlSet)stmt);
				return;
			}
			throw new NotSupportedException(Enum.GetName(typeof(ESqlStatementType), stmt.sqlstatementtype));
		}

		// Token: 0x060010E4 RID: 4324 RVA: 0x0030F78C File Offset: 0x0030D98C
		public override void preVisit(TElsifStmt elsifStmt)
		{
			this.acceptKeyword("elsif");
			if (elsifStmt.Condition != null)
			{
				elsifStmt.Condition.accept(this);
			}
			if (elsifStmt.ThenStatements != null && elsifStmt.ThenStatements.Count > 0)
			{
				this.acceptKeyword("then");
				this.acceptNewline();
				this.acceptSpace(4);
				this.preVisit(elsifStmt.ThenStatements);
				this.acceptNewline();
			}
		}

		// Token: 0x060010E5 RID: 4325 RVA: 0x0030F7F8 File Offset: 0x0030D9F8
		public override void preVisit(TAssignStmt assignStmt)
		{
			assignStmt.Left.accept(this);
			this.scriptWriter.addComparisonOperator(EComparisonType.equalsTo);
			assignStmt.Expression.accept(this);
		}

		// Token: 0x060010E6 RID: 4326 RVA: 0x0030F820 File Offset: 0x0030DA20
		public override void preVisit(TIfStmt ifStmt)
		{
			this.acceptKeyword("if");
			if (ifStmt.Condition != null)
			{
				ifStmt.Condition.accept(this);
			}
			if (ifStmt.ThenStatements != null && ifStmt.ThenStatements.Count > 0)
			{
				this.acceptKeyword("then");
				this.acceptNewline();
				this.acceptSpace(4);
				this.preVisit(ifStmt.ThenStatements);
				this.acceptNewline();
			}
			if (ifStmt.ElseifStatements != null)
			{
				this.preVisit(ifStmt.ElseifStatements);
			}
			if (ifStmt.ElseStatements != null && ifStmt.ElseStatements.Count > 0)
			{
				this.acceptKeyword("else");
				this.preVisit(ifStmt.ElseStatements);
				this.acceptNewline();
			}
			this.acceptKeyword("end");
			this.acceptKeyword("if");
			this.acceptNewline();
		}

		// Token: 0x060010E7 RID: 4327 RVA: 0x0030F8F0 File Offset: 0x0030DAF0
		public override void preVisit(TMssqlIfElse ifElse)
		{
			this.acceptKeyword("if");
			if (ifElse.Condition != null)
			{
				ifElse.Condition.accept(this);
			}
			if (ifElse.Stmt != null)
			{
				this.acceptNewline();
				this.acceptSpace(4);
				this.preVisitCustomSqlStatement(ifElse.Stmt);
			}
			if (ifElse.ElseStmt != null)
			{
				this.acceptNewline();
				this.acceptSpace(4);
				this.acceptKeyword("else");
				this.acceptNewline();
				this.acceptSpace(4);
				this.preVisitCustomSqlStatement(ifElse.ElseStmt);
			}
		}

		// Token: 0x060010E8 RID: 4328 RVA: 0x0030F978 File Offset: 0x0030DB78
		public override void preVisit(TAliasClause node)
		{
			if (node.HasAs)
			{
				this.acceptKeyword("as");
			}
			node.AliasName.accept(this);
			if (node.Columns != null)
			{
				this.acceptSpace(1);
				this.acceptSymbol("(");
				this.visitObjectNameList(node.Columns);
				this.acceptSymbol(")");
			}
		}

		// Token: 0x060010E9 RID: 4329 RVA: 0x0030F9D5 File Offset: 0x0030DBD5
		public override void preVisit(TWhereClause node)
		{
			if (node.Condition == null)
			{
				return;
			}
			this.acceptKeyword("where");
			node.Condition.accept(this);
		}

		// Token: 0x060010EA RID: 4330 RVA: 0x0030F9F8 File Offset: 0x0030DBF8
		public override void preVisit(TIsolationClause node)
		{
			this.acceptKeyword("with");
			switch (node.IsolationLevel)
			{
			case EIsolationLevel.db2RR:
				this.acceptKeyword("rr");
				return;
			case EIsolationLevel.db2RS:
				this.acceptKeyword("rs");
				return;
			case EIsolationLevel.db2CS:
				this.acceptKeyword("cs");
				return;
			case EIsolationLevel.db2UR:
				this.acceptKeyword("ur");
				return;
			case EIsolationLevel.db2RRExclusive:
				this.acceptKeyword("rr");
				this.acceptKeyword("USE");
				this.acceptKeyword("AND");
				this.acceptKeyword("KEEP");
				this.acceptKeyword("EXCLUSIVE");
				this.acceptKeyword("LOCKS");
				return;
			case EIsolationLevel.db2RRUpdate:
				this.acceptKeyword("rr");
				this.acceptKeyword("USE");
				this.acceptKeyword("AND");
				this.acceptKeyword("KEEP");
				this.acceptKeyword("UPDATE");
				this.acceptKeyword("LOCKS");
				return;
			case EIsolationLevel.db2RRShare:
				this.acceptKeyword("rr");
				this.acceptKeyword("USE");
				this.acceptKeyword("AND");
				this.acceptKeyword("KEEP");
				this.acceptKeyword("SHARE");
				this.acceptKeyword("LOCKS");
				return;
			case EIsolationLevel.db2RSExclusive:
				this.acceptKeyword("rs");
				this.acceptKeyword("USE");
				this.acceptKeyword("AND");
				this.acceptKeyword("KEEP");
				this.acceptKeyword("EXCLUSIVE");
				this.acceptKeyword("LOCKS");
				return;
			case EIsolationLevel.db2RSUpdate:
				this.acceptKeyword("rs");
				this.acceptKeyword("USE");
				this.acceptKeyword("AND");
				this.acceptKeyword("KEEP");
				this.acceptKeyword("UPDATE");
				this.acceptKeyword("LOCKS");
				return;
			case EIsolationLevel.db2RSShare:
				this.acceptKeyword("rs");
				this.acceptKeyword("USE");
				this.acceptKeyword("AND");
				this.acceptKeyword("KEEP");
				this.acceptKeyword("SHARE");
				this.acceptKeyword("LOCKS");
				return;
			default:
				return;
			}
		}

		// Token: 0x060010EB RID: 4331 RVA: 0x0030FC0C File Offset: 0x0030DE0C
		public override void preVisit(TIntoClause node)
		{
			if (node.BulkCollect)
			{
				this.acceptKeyword("bulk");
				this.acceptKeyword("collect");
			}
			this.acceptKeyword("into");
			if (node.ExprList != null)
			{
				this.acceptNewline();
				node.ExprList.accept(this);
				return;
			}
			node.IntoName.accept(this);
		}

		// Token: 0x060010EC RID: 4332 RVA: 0x0030FC69 File Offset: 0x0030DE69
		public override void preVisit(TTopClause node)
		{
			this.acceptKeyword("top");
			node.Expr.accept(this);
			if (node.Percent)
			{
				this.acceptKeyword("percent");
			}
			if (node.Withties)
			{
				this.acceptKeyword("with ties");
			}
		}

		// Token: 0x060010ED RID: 4333 RVA: 0x0030FCA8 File Offset: 0x0030DEA8
		public override void preVisit(TLimitClause node)
		{
			this.acceptKeyword("limit");
			if (node.Offset != null)
			{
				node.Offset.accept(this);
				this.acceptSymbol(",");
				node.Row_count.accept(this);
				return;
			}
			node.Row_count.accept(this);
		}

		// Token: 0x060010EE RID: 4334 RVA: 0x0030FCF8 File Offset: 0x0030DEF8
		public override void preVisit(TJoin node)
		{
			if (node.JoinItems.Count > 0)
			{
				if (node.Table != null)
				{
					node.Kind = 2;
				}
				else if (node.Join != null)
				{
					node.Kind = 3;
				}
			}
			if (node.WithParen)
			{
				for (int i = 0; i < node.NestedParen; i++)
				{
					this.acceptSymbol("(");
				}
			}
			int kind = node.Kind;
			if (kind != 1)
			{
				if (kind - 2 <= 1)
				{
					if (node.Kind == 2)
					{
						node.Table.accept(this);
					}
					else if (node.Kind == 3)
					{
						node.Join.accept(this);
					}
					for (int j = 0; j < node.JoinItems.Count; j++)
					{
						TParseTreeNode joinItem = node.JoinItems.getJoinItem(j);
						this.acceptNewline();
						joinItem.accept(this);
					}
				}
			}
			else
			{
				node.Table.accept(this);
			}
			if (node.WithParen)
			{
				for (int k = 0; k < node.NestedParen; k++)
				{
					this.acceptSymbol(")");
				}
			}
			if (node.AliasClause != null)
			{
				this.acceptSpace(1);
				node.AliasClause.accept(this);
			}
		}

		// Token: 0x060010EF RID: 4335 RVA: 0x0030FE14 File Offset: 0x0030E014
		public override void preVisit(TJoinItem joinItem)
		{
			switch (joinItem.JoinType)
			{
			case EJoinType.cross:
				this.acceptKeyword("cross");
				if (joinItem.JoinHint != EJoinHint.none)
				{
					this.acceptKeyword(EJoinHintHelper.ToString(joinItem.JoinHint));
				}
				this.acceptKeyword("join");
				goto IL_31C;
			case EJoinType.natural:
				this.acceptKeyword("natural");
				if (joinItem.JoinHint != EJoinHint.none)
				{
					this.acceptKeyword(EJoinHintHelper.ToString(joinItem.JoinHint));
				}
				this.acceptKeyword("join");
				goto IL_31C;
			case EJoinType.full:
				this.acceptKeyword("full");
				if (joinItem.JoinHint != EJoinHint.none)
				{
					this.acceptKeyword(EJoinHintHelper.ToString(joinItem.JoinHint));
				}
				this.acceptKeyword("join");
				goto IL_31C;
			case EJoinType.left:
				this.acceptKeyword("left");
				if (joinItem.JoinHint != EJoinHint.none)
				{
					this.acceptKeyword(EJoinHintHelper.ToString(joinItem.JoinHint));
				}
				this.acceptKeyword("join");
				goto IL_31C;
			case EJoinType.right:
				this.acceptKeyword("right");
				if (joinItem.JoinHint != EJoinHint.none)
				{
					this.acceptKeyword(EJoinHintHelper.ToString(joinItem.JoinHint));
				}
				this.acceptKeyword("join");
				goto IL_31C;
			case EJoinType.fullouter:
				this.acceptKeyword("full");
				this.acceptKeyword("outer");
				if (joinItem.JoinHint != EJoinHint.none)
				{
					this.acceptKeyword(EJoinHintHelper.ToString(joinItem.JoinHint));
				}
				this.acceptKeyword("join");
				goto IL_31C;
			case EJoinType.leftouter:
				this.acceptKeyword("left");
				this.acceptKeyword("outer");
				if (joinItem.JoinHint != EJoinHint.none)
				{
					this.acceptKeyword(EJoinHintHelper.ToString(joinItem.JoinHint));
				}
				this.acceptKeyword("join");
				goto IL_31C;
			case EJoinType.rightouter:
				this.acceptKeyword("right");
				this.acceptKeyword("outer");
				if (joinItem.JoinHint != EJoinHint.none)
				{
					this.acceptKeyword(EJoinHintHelper.ToString(joinItem.JoinHint));
				}
				this.acceptKeyword("join");
				goto IL_31C;
			case EJoinType.inner:
				this.acceptKeyword("inner");
				if (joinItem.JoinHint != EJoinHint.none)
				{
					this.acceptKeyword(EJoinHintHelper.ToString(joinItem.JoinHint));
				}
				this.acceptKeyword("join");
				goto IL_31C;
			case EJoinType.crossapply:
				this.acceptKeyword("cross");
				this.acceptKeyword("apply");
				goto IL_31C;
			case EJoinType.outerapply:
				this.acceptKeyword("outer");
				this.acceptKeyword("apply");
				goto IL_31C;
			case EJoinType.natural_inner:
				this.acceptKeyword("natural");
				this.acceptKeyword("inner");
				if (joinItem.JoinHint != EJoinHint.none)
				{
					this.acceptKeyword(EJoinHintHelper.ToString(joinItem.JoinHint));
				}
				this.acceptKeyword("join");
				goto IL_31C;
			case EJoinType.join:
				if (joinItem.JoinHint != EJoinHint.none)
				{
					this.acceptKeyword(EJoinHintHelper.ToString(joinItem.JoinHint));
				}
				this.acceptKeyword("join");
				goto IL_31C;
			}
			if (joinItem.JoinHint != EJoinHint.none)
			{
				this.acceptKeyword(EJoinHintHelper.ToString(joinItem.JoinHint));
			}
			this.acceptKeyword("join");
			IL_31C:
			if (joinItem.Table != null)
			{
				joinItem.Table.accept(this);
			}
			else if (joinItem.Join != null)
			{
				joinItem.Join.accept(this);
			}
			if (joinItem.OnCondition != null)
			{
				this.acceptKeyword("on");
				joinItem.OnCondition.accept(this);
			}
			if (joinItem.UsingColumns != null)
			{
				this.acceptKeyword("using");
				this.acceptSymbol("(");
				this.visitObjectNameList(joinItem.UsingColumns);
				this.acceptSymbol(")");
			}
		}

		// Token: 0x060010F0 RID: 4336 RVA: 0x003101BC File Offset: 0x0030E3BC
		public override void preVisit(TTable node)
		{
			if (node.ParenthesisCount > 0)
			{
				for (int i = 0; i < node.ParenthesisCount; i++)
				{
					this.acceptSymbol("(");
				}
			}
			if (node.ParenthesisAfterAliasCount > 0)
			{
				for (int j = 0; j < node.ParenthesisAfterAliasCount; j++)
				{
					this.acceptSymbol("(");
				}
			}
			if (node.TableKeyword)
			{
				this.acceptKeyword("table");
				this.acceptSymbol("(");
			}
			if (node.OnlyKeyword)
			{
				this.acceptKeyword("only");
				this.acceptSymbol("(");
			}
			if (node.LateralKeyword)
			{
				this.acceptKeyword("lateral");
				this.acceptSymbol("(");
			}
			switch (node.TableType)
			{
			case ETableSource.objectname:
				node.TableName.accept(this);
				if (node.Flashback != null)
				{
					this.acceptNewline();
					this.visitNodeByToken(node.Flashback);
				}
				break;
			case ETableSource.subquery:
				node.Subquery.accept(this);
				break;
			case ETableSource.tableExpr:
				node.TableExpr.accept(this);
				break;
			case ETableSource.function:
				node.FuncCall.accept(this);
				break;
			case ETableSource.rowList:
				node.RowList.accept(this);
				break;
			case ETableSource.containsTable:
				node.ContainsTable.accept(this);
				break;
			case ETableSource.openrowset:
				node.OpenRowSet.accept(this);
				break;
			case ETableSource.openxml:
				node.OpenXML.accept(this);
				break;
			case ETableSource.opendatasource:
				node.OpenDatasource.accept(this);
				break;
			case ETableSource.openquery:
				node.Openquery.accept(this);
				break;
			case ETableSource.datachangeTable:
				node.DatachangeTable.accept(this);
				break;
			case ETableSource.xmltable:
				node.XmlTable.accept(this);
				break;
			case ETableSource.informixOuter:
				node.OuterClause.accept(this);
				break;
			case ETableSource.table_ref_list:
				node.FromTableList.accept(this);
				break;
			case ETableSource.hiveFromQuery:
				node.HiveFromQuery.accept(this);
				break;
			case ETableSource.pivoted_table:
				node.PivotedTable.accept(this);
				break;
			}
			if (node.TableKeyword)
			{
				this.acceptSymbol(")");
			}
			if (node.OnlyKeyword)
			{
				this.acceptSymbol(")");
			}
			if (node.LateralKeyword)
			{
				this.acceptSymbol(")");
			}
			if (node.ParenthesisCount > 0)
			{
				for (int k = 0; k < node.ParenthesisCount; k++)
				{
					this.acceptSymbol(")");
				}
			}
			if (node.PxGranule != null)
			{
				this.acceptNewline();
				this.visitNodeByToken(node.PxGranule);
			}
			if (node.TableSample != null)
			{
				this.acceptNewline();
				this.visitNodeByToken(node.TableSample);
			}
			if (node.AliasClause != null)
			{
				this.acceptSpace(1);
				node.AliasClause.accept(this);
			}
			if (node.ParenthesisAfterAliasCount > 0)
			{
				for (int l = 0; l < node.ParenthesisAfterAliasCount; l++)
				{
					this.acceptSymbol(")");
				}
			}
			if (node.TableHintList != null)
			{
				this.acceptSpace(1);
				this.acceptKeyword("with");
				this.acceptSymbol("(");
				for (int m = 0; m < node.TableHintList.Count; m++)
				{
					node.TableHintList[m].accept(this);
					if (m != node.TableHintList.Count - 1)
					{
						this.acceptSymbol(",");
					}
				}
				this.acceptSymbol(")");
			}
			if (node.IndexHintList != null)
			{
				this.acceptSpace(1);
				for (int n = 0; n < node.IndexHintList.Count; n++)
				{
					node.IndexHintList[n].accept(this);
				}
			}
		}

		// Token: 0x060010F1 RID: 4337 RVA: 0x00310565 File Offset: 0x0030E765
		public override void preVisit(TTableHint node)
		{
			this.visitNodeByToken(node);
		}

		// Token: 0x060010F2 RID: 4338 RVA: 0x00310570 File Offset: 0x0030E770
		public override void preVisit(TMultiTarget node)
		{
			this.acceptSymbol("(");
			if (node.SubQuery != null)
			{
				node.SubQuery.accept(this);
			}
			else if (node.ColumnList != null)
			{
				node.ColumnList.accept(this);
			}
			this.acceptSymbol(")");
		}

		// Token: 0x060010F3 RID: 4339 RVA: 0x003105C0 File Offset: 0x0030E7C0
		public override void preVisit(TResultColumnList nodeList)
		{
			for (int i = 0; i < nodeList.Count; i++)
			{
				nodeList.getResultColumn(i).accept(this);
				if (i != nodeList.Count - 1)
				{
					this.acceptSymbol(",");
				}
			}
		}

		// Token: 0x060010F4 RID: 4340 RVA: 0x00310604 File Offset: 0x0030E804
		public override void preVisit(TMultiTargetList nodeList)
		{
			this.acceptSymbol("(");
			this.acceptKeyword("values");
			for (int i = 0; i < nodeList.Count; i++)
			{
				nodeList[i].accept(this);
				if (i != nodeList.Count - 1)
				{
					this.acceptSymbol(",");
				}
			}
			this.acceptSymbol(")");
		}

		// Token: 0x060010F5 RID: 4341 RVA: 0x00310668 File Offset: 0x0030E868
		public override void preVisit(THierarchical node)
		{
			if (node.StartWithClause != null)
			{
				this.acceptKeyword("start");
				this.acceptKeyword("with");
				node.StartWithClause.accept(this);
			}
			for (int i = 0; i < node.ConnectByList.Count; i++)
			{
				node.ConnectByList[i].accept(this);
				if (i != node.ConnectByList.Count - 1)
				{
					this.acceptNewline();
				}
			}
		}

		// Token: 0x060010F6 RID: 4342 RVA: 0x003106DD File Offset: 0x0030E8DD
		public override void preVisit(TConnectByClause node)
		{
			this.acceptKeyword("connect");
			this.acceptKeyword("by");
			if (node.NoCycle)
			{
				this.acceptKeyword("nocycle");
			}
			node.Condition.accept(this);
		}

		// Token: 0x060010F7 RID: 4343 RVA: 0x00310714 File Offset: 0x0030E914
		public override void preVisit(TGroupBy node)
		{
			if (node.Items != null)
			{
				this.acceptKeyword("group");
				this.acceptKeyword("by");
				for (int i = 0; i < node.Items.Count; i++)
				{
					node.Items.getGroupByItem(i).accept(this);
					if (i != node.Items.Count - 1)
					{
						this.acceptSymbol(",");
					}
				}
			}
			if (node.HavingClause != null)
			{
				this.acceptKeyword("having");
				node.HavingClause.accept(this);
			}
		}

		// Token: 0x060010F8 RID: 4344 RVA: 0x003107A1 File Offset: 0x0030E9A1
		public override void preVisit(TGroupByItem node)
		{
			if (node.Expr != null)
			{
				node.Expr.accept(this);
				return;
			}
			if (node.GroupingSet != null)
			{
				node.GroupingSet.accept(this);
				return;
			}
			if (node.RollupCube != null)
			{
				node.RollupCube.accept(this);
			}
		}

		// Token: 0x060010F9 RID: 4345 RVA: 0x003107E4 File Offset: 0x0030E9E4
		public override void preVisit(TOrderBy node)
		{
			if (node.Items.Count == 0)
			{
				return;
			}
			this.acceptKeyword("order");
			if (node.Siblings)
			{
				this.acceptKeyword("siblings");
			}
			this.acceptKeyword("by");
			for (int i = 0; i < node.Items.Count; i++)
			{
				node.Items.getOrderByItem(i).accept(this);
				if (i != node.Items.Count - 1)
				{
					this.acceptSymbol(",");
				}
			}
		}

		// Token: 0x060010FA RID: 4346 RVA: 0x0031086C File Offset: 0x0030EA6C
		public override void preVisit(TOrderByItem node)
		{
			if (node.SortKey != null)
			{
				node.SortKey.accept(this);
			}
			if (node.SortOrder == ESortType.asc)
			{
				this.acceptKeyword("asc");
			}
			else if (node.SortOrder == ESortType.desc)
			{
				this.acceptKeyword("desc");
			}
			switch (node.NullOrder)
			{
			case ENullOrder.notSet:
				break;
			case ENullOrder.nullsFirst:
				this.acceptKeyword("nulls");
				this.acceptKeyword("first");
				return;
			case ENullOrder.nullsLast:
				this.acceptKeyword("nulls");
				this.acceptKeyword("last");
				break;
			default:
				return;
			}
		}

		// Token: 0x060010FB RID: 4347 RVA: 0x00310900 File Offset: 0x0030EB00
		public override void preVisit(TCTE node)
		{
			node.TableName.accept(this);
			if (node.ColumnList != null)
			{
				this.acceptSymbol("(");
				for (int i = 0; i < node.ColumnList.Count; i++)
				{
					node.ColumnList.getObjectName(i).accept(this);
					if (i != node.ColumnList.Count - 1)
					{
						this.acceptSymbol(",");
					}
				}
				this.acceptSymbol(")");
			}
			this.acceptKeyword("as");
			this.acceptNewline();
			if (node.Subquery != null)
			{
				node.Subquery.accept(this);
				return;
			}
			if (node.UpdateStmt != null)
			{
				node.UpdateStmt.accept(this);
				return;
			}
			if (node.InsertStmt != null)
			{
				node.InsertStmt.accept(this);
				return;
			}
			if (node.DeleteStmt != null)
			{
				node.DeleteStmt.accept(this);
			}
		}

		// Token: 0x060010FC RID: 4348 RVA: 0x003109E0 File Offset: 0x0030EBE0
		public override void preVisit(TPivotInClause node)
		{
			this.acceptKeyword("in");
			if (node.Items != null)
			{
				this.acceptSymbol("(");
				this.visitResultColumnList(node.Items);
				this.acceptSymbol(")");
			}
			if (node.SubQuery != null)
			{
				node.SubQuery.accept(this);
			}
		}

		// Token: 0x060010FD RID: 4349 RVA: 0x00310A38 File Offset: 0x0030EC38
		public override void preVisit(TPivotedTable node)
		{
			for (int i = 0; i < node.PivotClauseList.Count; i++)
			{
				if (i == 0)
				{
					node.TableSource.accept(this);
				}
				TPivotClause tpivotClause = node.PivotClauseList[i];
				tpivotClause.accept(this);
				if (tpivotClause.AliasClause != null)
				{
					tpivotClause.AliasClause.accept(this);
				}
			}
		}

		// Token: 0x060010FE RID: 4350 RVA: 0x00310A94 File Offset: 0x0030EC94
		public override void preVisit(TPivotClause node)
		{
			if (node.Type == 1)
			{
				this.acceptKeyword("pivot");
				this.acceptSymbol("(");
				if (node.Aggregation_function != null)
				{
					node.Aggregation_function.accept(this);
				}
				else if (node.Aggregation_function_list != null)
				{
					if (node.Aggregation_function_list.Count > 1)
					{
						this.acceptSymbol("(");
					}
					for (int i = 0; i < node.Aggregation_function_list.Count; i++)
					{
						node.Aggregation_function_list.getResultColumn(i).accept(this);
						if (i != node.Aggregation_function_list.Count - 1)
						{
							this.acceptSymbol(",");
						}
					}
					if (node.Aggregation_function_list.Count > 1)
					{
						this.acceptSymbol(")");
					}
				}
				this.acceptKeyword("for");
				if (node.PivotColumnList.Count > 1)
				{
					this.acceptSymbol("(");
				}
				for (int j = 0; j < node.PivotColumnList.Count; j++)
				{
					node.PivotColumnList[j].accept(this);
					if (j != node.PivotColumnList.Count - 1)
					{
						this.acceptSymbol(",");
					}
				}
				if (node.PivotColumnList.Count > 1)
				{
					this.acceptSymbol(")");
				}
				node.PivotInClause.accept(this);
				this.acceptSymbol(")");
				return;
			}
			this.acceptKeyword("unpivot");
			this.acceptSymbol("(");
			if (node.ValueColumnList.Count > 1)
			{
				this.acceptSymbol("(");
			}
			for (int k = 0; k < node.ValueColumnList.Count; k++)
			{
				node.ValueColumnList.getObjectName(k).accept(this);
				if (k != node.ValueColumnList.Count - 1)
				{
					this.acceptSymbol(",");
				}
			}
			if (node.ValueColumnList.Count > 1)
			{
				this.acceptSymbol(")");
			}
			this.acceptKeyword("for");
			if (node.PivotColumnList.Count > 1)
			{
				this.acceptSymbol("(");
			}
			for (int l = 0; l < node.PivotColumnList.Count; l++)
			{
				node.PivotColumnList[l].accept(this);
				if (l != node.PivotColumnList.Count - 1)
				{
					this.acceptSymbol(",");
				}
			}
			if (node.PivotColumnList.Count > 1)
			{
				this.acceptSymbol(")");
			}
			node.UnpivotInClause.accept(this);
			this.acceptSymbol(")");
		}

		// Token: 0x060010FF RID: 4351 RVA: 0x00310D10 File Offset: 0x0030EF10
		public override void preVisit(TUnpivotInClauseItem node)
		{
			if (node.Column != null)
			{
				node.Column.accept(this);
			}
			else if (node.ColumnList != null)
			{
				this.acceptSymbol("(");
				for (int i = 0; i < node.ColumnList.Count; i++)
				{
					node.ColumnList.getObjectName(i).accept(this);
					if (i != node.ColumnList.Count - 1)
					{
						this.acceptSymbol(",");
					}
				}
				this.acceptSymbol(")");
			}
			if (node.Constant != null)
			{
				this.acceptKeyword("as");
				node.Constant.accept(this);
				return;
			}
			if (node.ConstantList != null)
			{
				this.acceptKeyword("as");
				this.acceptSymbol("(");
				for (int j = 0; j < node.ConstantList.Count; j++)
				{
					node.ConstantList[j].accept(this);
					if (j != node.ConstantList.Count - 1)
					{
						this.acceptSymbol(",");
					}
				}
				this.acceptSymbol(")");
			}
		}

		// Token: 0x06001100 RID: 4352 RVA: 0x00310E20 File Offset: 0x0030F020
		public override void preVisit(TUnpivotInClause node)
		{
			this.acceptKeyword("in");
			this.acceptSymbol("(");
			for (int i = 0; i < node.Items.Count; i++)
			{
				node.Items[i].accept(this);
				if (i != node.Items.Count - 1)
				{
					this.acceptSymbol(",");
				}
			}
			this.acceptSymbol(")");
		}

		// Token: 0x06001101 RID: 4353 RVA: 0x00310E94 File Offset: 0x0030F094
		public override void preVisit(TCaseExpression node)
		{
			this.acceptKeyword("case");
			if (node.Input_expr != null)
			{
				node.Input_expr.accept(this);
			}
			for (int i = 0; i < node.WhenClauseItemList.Count; i++)
			{
				node.WhenClauseItemList.getWhenClauseItem(i).accept(this);
				if (i != node.WhenClauseItemList.Count - 1)
				{
					this.acceptNewline();
				}
			}
			if (node.Else_expr != null)
			{
				this.acceptNewline();
				this.acceptKeyword("else");
				node.Else_expr.accept(this);
			}
			if (node.Else_statement_list.Count > 0)
			{
				node.Else_statement_list.accept(this);
			}
			this.acceptNewline();
			this.acceptKeyword("end");
		}

		// Token: 0x06001102 RID: 4354 RVA: 0x00310F50 File Offset: 0x0030F150
		public override void preVisit(TWhenClauseItem node)
		{
			this.acceptKeyword("when");
			node.Comparison_expr.accept(this);
			this.acceptNewline();
			this.acceptKeyword("then");
			if (node.Return_expr != null)
			{
				node.Return_expr.accept(this);
				return;
			}
			if (node.Statement_list.Count > 0)
			{
				for (int i = 0; i < node.Statement_list.Count; i++)
				{
					node.Statement_list.get(i).accept(this);
				}
			}
		}

		// Token: 0x06001103 RID: 4355 RVA: 0x00310FD0 File Offset: 0x0030F1D0
		public override void preVisit(TWindowDef node)
		{
			if (node.keepDenseRankClause != null)
			{
				node.keepDenseRankClause.accept(this);
			}
			if (node.withinGroup != null)
			{
				this.acceptKeyword("within");
				this.acceptKeyword("group");
				this.acceptSymbol("(");
				if (node.withinGroup.orderBy != null)
				{
					node.withinGroup.orderBy.accept(this);
				}
				this.acceptSymbol(")");
			}
			if (node.includingOverClause)
			{
				this.acceptKeyword("over");
				this.acceptSymbol("(");
				if (node.PartitionClause != null)
				{
					this.acceptKeyword("partition");
					this.acceptKeyword("by");
					this.visitExprList(node.PartitionClause.ExpressionList);
				}
				if (node.orderBy != null)
				{
					node.orderBy.accept(this);
				}
				if (node.WindowFrame != null)
				{
					this.acceptNewline();
					node.WindowFrame.accept(this);
				}
				this.acceptSymbol(")");
			}
			if (node.Name != null)
			{
				this.preVisit(node.Name);
			}
		}

		// Token: 0x06001104 RID: 4356 RVA: 0x003110E0 File Offset: 0x0030F2E0
		public override void preVisit(TWindowFrame node)
		{
			if (node.WindowExpressionType == ELimitRowType.Rows)
			{
				this.acceptKeyword("rows");
			}
			else if (node.WindowExpressionType == ELimitRowType.Range)
			{
				this.acceptKeyword("range");
			}
			if (node.StartBoundary != null && node.EndBoundary != null)
			{
				this.acceptKeyword("between");
				node.StartBoundary.accept(this);
				this.acceptKeyword("and");
				node.EndBoundary.accept(this);
				return;
			}
			if (node.StartBoundary != null)
			{
				node.StartBoundary.accept(this);
			}
		}

		// Token: 0x06001105 RID: 4357 RVA: 0x0031116C File Offset: 0x0030F36C
		public override void preVisit(TWindowFrameBoundary node)
		{
			if (node.BoundaryNumber != null)
			{
				node.BoundaryNumber.accept(this);
			}
			if (node.ExclusionClause != null && node.ExclusionClause.excludeType == EWindowExcludeType.currentRow)
			{
				this.acceptKeyword("current");
				this.acceptKeyword("row");
			}
			if (node.BoundaryType == EBoundaryType.ebtCurrentRow)
			{
				this.acceptKeyword("current");
				this.acceptKeyword("row");
				return;
			}
			if (node.BoundaryType == EBoundaryType.ebtFollowing)
			{
				this.acceptKeyword("following");
				return;
			}
			if (node.BoundaryType == EBoundaryType.ebtPreceding)
			{
				this.acceptKeyword("preceding");
				return;
			}
			if (node.BoundaryType == EBoundaryType.ebtUnboundedFollowing)
			{
				this.acceptKeyword("unbounded");
				this.acceptKeyword("following");
				return;
			}
			if (node.BoundaryType == EBoundaryType.ebtUnboundedPreceding)
			{
				this.acceptKeyword("unbounded");
				this.acceptKeyword("preceding");
			}
		}

		// Token: 0x06001106 RID: 4358 RVA: 0x00311240 File Offset: 0x0030F440
		public override void preVisit(TForUpdate node)
		{
			switch (node.ForUpdateType)
			{
			case TForUpdate.EForUpdateType.forUpdate:
				this.acceptKeyword("for");
				this.acceptKeyword("update");
				break;
			case TForUpdate.EForUpdateType.forUpdateOf:
				this.acceptKeyword("for");
				this.acceptKeyword("update");
				this.acceptKeyword("of");
				break;
			case TForUpdate.EForUpdateType.forReadOnly:
				this.acceptKeyword("read");
				this.acceptKeyword("only");
				break;
			case TForUpdate.EForUpdateType.forXML:
				this.visitNodeByToken(node);
				break;
			}
			if (node.ColumnRefs != null)
			{
				this.visitObjectNameList(node.ColumnRefs);
			}
			if (node.Nowait)
			{
				this.acceptKeyword("nowait");
			}
			if (node.Wait)
			{
				this.acceptKeyword("wait");
				this.acceptIdentifier(node.WaitValue);
			}
		}

		// Token: 0x06001107 RID: 4359 RVA: 0x0031130C File Offset: 0x0030F50C
		public override void preVisit(TTruncateStatement stmt)
		{
			this.acceptKeyword("truncate");
			if (stmt.TableKeyword)
			{
				this.acceptKeyword("table");
			}
			stmt.TableName.accept(this);
			if (stmt.ImmediateToken != null)
			{
				this.acceptSpace(1);
				this.acceptToken(stmt.ImmediateToken);
			}
		}

		// Token: 0x06001108 RID: 4360 RVA: 0x00311360 File Offset: 0x0030F560
		public override void preVisit(TDeleteSqlStatement stmt)
		{
			if (stmt.CteList != null)
			{
				this.acceptKeyword("with");
				this.visitCTEList(stmt.CteList);
			}
			this.acceptKeyword("delete");
			if (stmt.OracleHint != null)
			{
				this.acceptLiteral(stmt.OracleHint);
			}
			if (stmt.TopClause != null)
			{
				stmt.TopClause.accept(this);
			}
			if (stmt.FromKeyword)
			{
				this.acceptKeyword("from");
			}
			stmt.TargetTable.accept(this);
			if (stmt.joins.Count > 0)
			{
				this.acceptNewline();
				this.acceptKeyword("from");
				this.visitJoinList(stmt.joins);
			}
			if (stmt.OutputClause != null)
			{
				stmt.OutputClause.accept(this);
			}
			if (stmt.WhereClause != null)
			{
				this.acceptNewline();
				stmt.WhereClause.accept(this);
			}
			if (stmt.OrderByClause != null)
			{
				this.acceptNewline();
				stmt.OrderByClause.accept(this);
			}
			if (stmt.LimitClause != null)
			{
				this.acceptNewline();
				stmt.LimitClause.accept(this);
			}
			if (stmt.ReturningClause != null)
			{
				stmt.ReturningClause.accept(this);
			}
		}

		// Token: 0x06001109 RID: 4361 RVA: 0x00311480 File Offset: 0x0030F680
		public override void preVisit(TUpdateSqlStatement stmt)
		{
			if (stmt.CteList != null)
			{
				this.acceptKeyword("with");
				this.visitCTEList(stmt.CteList);
			}
			this.acceptKeyword("update");
			if (stmt.OracleHint != null)
			{
				this.acceptLiteral(stmt.OracleHint);
			}
			if (stmt.TopClause != null)
			{
				stmt.TopClause.accept(this);
			}
			if (this.getDBVerdor(stmt) == EDbVendor.dbvmysql)
			{
				if (stmt.joins.size() > 0)
				{
					this.visitJoinList(stmt.joins);
				}
				else
				{
					stmt.TargetTable.accept(this);
				}
			}
			else
			{
				stmt.TargetTable.accept(this);
			}
			this.acceptNewline();
			this.acceptKeyword("set");
			this.visitResultColumnList(stmt.ResultColumnList);
			if (this.getDBVerdor(stmt) != EDbVendor.dbvmysql && stmt.joins.Count > 0)
			{
				this.acceptNewline();
				this.acceptKeyword("from");
				this.visitJoinList(stmt.joins);
			}
			if (stmt.WhereClause != null)
			{
				this.acceptNewline();
				stmt.WhereClause.accept(this);
			}
			if (stmt.OrderByClause != null)
			{
				stmt.OrderByClause.accept(this);
			}
			if (stmt.LimitClause != null)
			{
				stmt.LimitClause.accept(this);
			}
			if (stmt.OutputClause != null)
			{
				stmt.OutputClause.accept(this);
			}
			if (stmt.ReturningClause != null)
			{
				stmt.ReturningClause.accept(this);
			}
		}

		// Token: 0x0600110A RID: 4362 RVA: 0x003115DD File Offset: 0x0030F7DD
		private EDbVendor getDBVerdor(TCustomSqlStatement stmt)
		{
			if (stmt.GSharpSqlParser != null)
			{
				return stmt.GSharpSqlParser.DbVendor;
			}
			return stmt.dbvendor;
		}

		// Token: 0x0600110B RID: 4363 RVA: 0x003115FC File Offset: 0x0030F7FC
		public override void preVisit(TInsertSqlStatement stmt)
		{
			if (stmt.CteList != null)
			{
				this.acceptKeyword("with");
				this.visitCTEList(stmt.CteList);
			}
			if (stmt.InsertToken != null)
			{
				this.acceptToken(stmt.InsertToken);
			}
			else
			{
				this.acceptKeyword("insert");
			}
			if (stmt.OracleHint != null)
			{
				this.acceptLiteral(stmt.OracleHint);
			}
			if (stmt.Priority_delayed != null)
			{
				this.acceptToken(stmt.Priority_delayed);
			}
			this.acceptKeyword("into");
			if (stmt.TargetTable != null)
			{
				stmt.TargetTable.accept(this);
			}
			if (stmt.ColumnList != null)
			{
				this.acceptSymbol("(");
				this.visitObjectNameList(stmt.ColumnList);
				this.acceptSymbol(")");
			}
			switch (stmt.InsertSource)
			{
			case EInsertSource.values:
				this.acceptNewline();
				this.acceptKeyword("values");
				for (int i = 0; i < stmt.Values.Count; i++)
				{
					TMultiTarget multiTarget = stmt.Values.getMultiTarget(i);
					this.acceptSymbol("(");
					for (int j = 0; j < multiTarget.ColumnList.Count; j++)
					{
						if (!multiTarget.ColumnList.getResultColumn(j).PlaceHolder)
						{
							multiTarget.ColumnList.getResultColumn(j).Expr.accept(this);
							if (j != multiTarget.ColumnList.Count - 1)
							{
								this.acceptSymbol(",");
							}
						}
					}
					this.acceptSymbol(")");
					if (i != stmt.Values.Count - 1)
					{
						this.acceptSymbol(",");
					}
				}
				break;
			case EInsertSource.subquery:
				this.acceptNewline();
				stmt.SubQuery.accept(this);
				break;
			case EInsertSource.set_column_value:
				this.acceptKeyword("set");
				for (int k = 0; k < stmt.SetColumnValues.size(); k++)
				{
					stmt.SetColumnValues.getResultColumn(k).accept(this);
					if (k != stmt.SetColumnValues.size() - 1)
					{
						this.acceptSymbol(",");
					}
				}
				break;
			}
			if (stmt.OnDuplicateKeyUpdate != null)
			{
				this.acceptKeyword("on");
				this.acceptKeyword("duplicate");
				this.acceptKeyword("key");
				this.acceptKeyword("update");
				this.visitResultColumnList(stmt.OnDuplicateKeyUpdate);
			}
			if (stmt.ReturningClause != null)
			{
				this.acceptNewline();
				stmt.ReturningClause.accept(this);
			}
		}

		// Token: 0x0600110C RID: 4364 RVA: 0x00311880 File Offset: 0x0030FA80
		public override void preVisit(TMergeSqlStatement stmt)
		{
			if (stmt.CteList != null)
			{
				this.acceptKeyword("with");
				this.visitCTEList(stmt.CteList);
			}
			this.acceptKeyword("merge");
			if (stmt.OracleHint != null)
			{
				this.acceptLiteral(stmt.OracleHint);
			}
			this.acceptKeyword("into");
			stmt.TargetTable.accept(this);
			this.acceptKeyword("using");
			stmt.UsingTable.accept(this);
			this.acceptKeyword("on");
			this.acceptSymbol("(");
			stmt.Condition.accept(this);
			this.acceptSymbol(")");
			this.acceptNewline();
			if (stmt.WhenClauses != null)
			{
				for (int i = 0; i < stmt.WhenClauses.Count; i++)
				{
					stmt.WhenClauses[i].accept(this);
				}
			}
		}

		// Token: 0x0600110D RID: 4365 RVA: 0x0031195C File Offset: 0x0030FB5C
		public override void preVisit(TMergeWhenClause node)
		{
			switch (node.Type)
			{
			case 1:
				this.acceptKeyword("when");
				this.acceptKeyword("matched");
				this.acceptKeyword("then");
				break;
			case 2:
				this.acceptKeyword("when");
				this.acceptKeyword("not");
				this.acceptKeyword("matched");
				this.acceptKeyword("then");
				break;
			case 3:
				this.acceptKeyword("when");
				this.acceptKeyword("matched");
				this.acceptKeyword("and");
				node.Condition.accept(this);
				this.acceptKeyword("then");
				break;
			case 4:
				this.acceptKeyword("when");
				this.acceptKeyword("not");
				this.acceptKeyword("matched");
				this.acceptKeyword("and");
				node.Condition.accept(this);
				this.acceptKeyword("then");
				break;
			case 5:
				this.acceptKeyword("when");
				this.acceptKeyword("not");
				this.acceptKeyword("matched");
				this.acceptKeyword("by");
				this.acceptKeyword("target");
				this.acceptKeyword("then");
				break;
			case 6:
				this.acceptKeyword("when");
				this.acceptKeyword("not");
				this.acceptKeyword("matched");
				this.acceptKeyword("by");
				this.acceptKeyword("target");
				this.acceptKeyword("and");
				node.Condition.accept(this);
				this.acceptKeyword("then");
				break;
			case 7:
				this.acceptKeyword("when");
				this.acceptKeyword("not");
				this.acceptKeyword("matched");
				this.acceptKeyword("by");
				this.acceptKeyword("source");
				this.acceptKeyword("then");
				break;
			case 8:
				this.acceptKeyword("when");
				this.acceptKeyword("not");
				this.acceptKeyword("matched");
				this.acceptKeyword("by");
				this.acceptKeyword("source");
				this.acceptKeyword("and");
				node.Condition.accept(this);
				this.acceptKeyword("then");
				break;
			}
			if (node.UpdateClause != null)
			{
				node.UpdateClause.accept(this);
			}
			if (node.InsertClause != null)
			{
				node.InsertClause.accept(this);
			}
			if (node.DeleteClause != null)
			{
				node.DeleteClause.accept(this);
			}
		}

		// Token: 0x0600110E RID: 4366 RVA: 0x00311BF8 File Offset: 0x0030FDF8
		public override void preVisit(TMergeUpdateClause node)
		{
			this.acceptKeyword("update");
			this.acceptKeyword("set");
			if (node.UpdateColumnList != null)
			{
				this.visitResultColumnList(node.UpdateColumnList);
			}
			if (node.UpdateWhereClause != null)
			{
				this.acceptNewline();
				this.acceptKeyword("where");
				node.UpdateWhereClause.accept(this);
			}
			if (node.DeleteWhereClause != null)
			{
				this.acceptNewline();
				this.acceptKeyword("delete");
				this.acceptKeyword("where");
				node.DeleteWhereClause.accept(this);
			}
		}

		// Token: 0x0600110F RID: 4367 RVA: 0x00311C84 File Offset: 0x0030FE84
		public override void preVisit(TMergeInsertClause node)
		{
			this.acceptKeyword("insert");
			if (node.ColumnList != null)
			{
				this.acceptSymbol("(");
				this.visitObjectNameList(node.ColumnList);
				this.acceptSymbol(")");
			}
			this.acceptKeyword("values");
			if (node.Valuelist != null)
			{
				this.acceptSymbol("(");
				this.visitResultColumnList(node.Valuelist);
				this.acceptSymbol(")");
			}
			if (node.InsertWhereClause != null)
			{
				this.acceptNewline();
				this.acceptKeyword("where");
				node.InsertWhereClause.accept(this);
			}
		}

		// Token: 0x06001110 RID: 4368 RVA: 0x00311D20 File Offset: 0x0030FF20
		public override void preVisit(TMergeDeleteClause node)
		{
		}

		// Token: 0x06001111 RID: 4369 RVA: 0x00311D24 File Offset: 0x0030FF24
		public override void preVisit(TCreateTableSqlStatement stmt)
		{
			this.acceptKeyword("create");
			if (stmt.stGlobal != null)
			{
				this.acceptKeyword("global");
			}
			if (stmt.stLocal != null)
			{
				this.acceptKeyword("local");
			}
			if (stmt.stTemp != null)
			{
				this.acceptKeyword("temp");
			}
			if (stmt.stTemporary != null)
			{
				this.acceptKeyword("temporary");
			}
			this.acceptKeyword("table");
			stmt.TargetTable.accept(this);
			if (stmt.SubQuery != null)
			{
				this.acceptKeyword("as");
				this.acceptNewline();
				stmt.SubQuery.accept(this);
			}
			else
			{
				this.acceptSymbol("(");
				this.acceptNewline();
				for (int i = 0; i < stmt.ColumnList.Count; i++)
				{
					stmt.ColumnList.getColumn(i).accept(this);
					if (i != stmt.ColumnList.Count - 1)
					{
						this.acceptSymbol(",");
						this.acceptSpace(1);
					}
				}
				if (stmt.TableConstraints != null && stmt.TableConstraints.Count > 0)
				{
					this.acceptSymbol(",");
					this.acceptNewline();
					for (int j = 0; j < stmt.TableConstraints.Count; j++)
					{
						stmt.TableConstraints.getConstraint(j).accept(this);
						if (j != stmt.TableConstraints.Count - 1)
						{
							this.acceptSymbol(",");
							this.acceptSpace(1);
						}
					}
				}
				this.acceptNewline();
				this.acceptSymbol(")");
			}
			if (stmt.MySQLTableOptionList != null && stmt.MySQLTableOptionList.Count > 0)
			{
				for (int k = 0; k < stmt.MySQLTableOptionList.Count; k++)
				{
					this.preVisit(stmt.MySQLTableOptionList[k]);
				}
			}
		}

		// Token: 0x06001112 RID: 4370 RVA: 0x00311EE4 File Offset: 0x003100E4
		public override void preVisit(TMySQLCreateTableOption option)
		{
			switch (option.tableOption)
			{
			case ETableOption.EO_AUTO_INCREMENT:
				this.acceptKeyword("auto_increment");
				break;
			case ETableOption.EO_AVG_ROW_LENGTH:
				this.acceptKeyword("avg_row_length");
				break;
			case ETableOption.EO_CHARACTER_SET:
				this.acceptKeyword("character set");
				break;
			case ETableOption.EO_CHECKSUM:
				this.acceptKeyword("checksum");
				break;
			case ETableOption.EO_COLLATE:
				this.acceptKeyword("collate");
				break;
			case ETableOption.EO_COMMENT:
				this.acceptKeyword("comment");
				break;
			case ETableOption.EO_COMPRESSION:
				this.acceptKeyword("compression");
				break;
			case ETableOption.EO_CONNECTION:
				this.acceptKeyword("connection");
				break;
			case ETableOption.EO_DATA_DIRECTORY:
				this.acceptKeyword("data directory");
				break;
			case ETableOption.EO_INDEX_DIRECTORY:
				this.acceptKeyword("index directory");
				break;
			case ETableOption.EO_DELAY_KEY_WRITE:
				this.acceptKeyword("delay_key_write");
				break;
			case ETableOption.EO_ENCRYPTION:
				this.acceptKeyword("encrytion");
				break;
			case ETableOption.EO_ENGINE:
				this.acceptKeyword("engine");
				break;
			case ETableOption.EO_INSERT_METHOD:
				this.acceptKeyword("insert_method");
				break;
			case ETableOption.EO_KEY_BLOCK_SIZE:
				this.acceptKeyword("key_block_size");
				break;
			case ETableOption.EO_MAX_ROWS:
				this.acceptKeyword("max_rows");
				break;
			case ETableOption.EO_MIN_ROWS:
				this.acceptKeyword("min_rows");
				break;
			case ETableOption.EO_PACK_KEYS:
				this.acceptKeyword("pack_keys");
				break;
			case ETableOption.EO_PASSWORD:
				this.acceptKeyword("password");
				break;
			case ETableOption.EO_RAID_TYPE:
				this.acceptKeyword("raid_type");
				break;
			case ETableOption.EO_RAID_CHUNKS:
				this.acceptKeyword("raid_chunks");
				break;
			case ETableOption.EO_RAID_CHUNKSIZE:
				this.acceptKeyword("raid_chunksize");
				break;
			case ETableOption.EO_ROW_FORMAT:
				this.acceptKeyword("row_format");
				break;
			case ETableOption.EO_STATS_AUTO_RECALC:
				this.acceptKeyword("stats_auto_recalc");
				break;
			case ETableOption.EO_STATS_PERSISTENT:
				this.acceptKeyword("stats_persistent");
				break;
			case ETableOption.EO_STATS_SAMPLE_PAGES:
				this.acceptKeyword("stats_sample_pages");
				break;
			case ETableOption.EO_UNION:
				this.acceptKeyword("union");
				break;
			case ETableOption.EO_TYPE:
				this.acceptKeyword("type");
				break;
			}
			this.acceptSymbol("=");
			this.acceptKeyword(option.OptionValue);
		}

		// Token: 0x06001113 RID: 4371 RVA: 0x00312130 File Offset: 0x00310330
		public override void preVisit(TColumnDefinition node)
		{
			node.ColumnName.accept(this);
			if (node.Datatype != null)
			{
				node.Datatype.accept(this);
			}
			if (node.DefaultExpression != null)
			{
				this.acceptKeyword("default");
				node.DefaultExpression.accept(this);
			}
			if (node.Null)
			{
				this.acceptKeyword("null");
			}
			if (node.Constraints != null && node.Constraints.Count > 0)
			{
				for (int i = 0; i < node.Constraints.Count; i++)
				{
					node.Constraints.getConstraint(i).accept(this);
				}
			}
		}

		// Token: 0x06001114 RID: 4372 RVA: 0x003121D0 File Offset: 0x003103D0
		public override void preVisit(TConstraint node)
		{
			if (node.ConstraintName != null)
			{
				this.acceptKeyword("constraint");
				node.ConstraintName.accept(this);
			}
			if (node.Clustered)
			{
				this.acceptKeyword("clustered");
			}
			switch (node.Constraint_type)
			{
			case EConstraintType.notnull:
				this.acceptKeyword("not");
				this.acceptKeyword("null");
				return;
			case EConstraintType.unique:
				this.acceptKeyword("unique");
				if (node.ColumnList != null)
				{
					this.acceptSymbol("(");
					this.visitObjectNameList(node.ColumnList);
					this.acceptSymbol(")");
					return;
				}
				break;
			case EConstraintType.primary_key:
				this.acceptKeyword("primary");
				this.acceptKeyword("key");
				if (node.ColumnList != null)
				{
					this.acceptSymbol("(");
					this.visitObjectNameList(node.ColumnList);
					this.acceptSymbol(")");
					return;
				}
				if (node.IndexCols != null)
				{
					this.acceptSymbol("(");
					this.visitIndexColNameList(node.IndexCols);
					this.acceptSymbol(")");
					return;
				}
				break;
			case EConstraintType.foreign_key:
				this.acceptKeyword("foreign");
				this.acceptKeyword("key");
				if (node.ColumnList != null)
				{
					this.acceptSymbol("(");
					this.visitObjectNameList(node.ColumnList);
					this.acceptSymbol(")");
				}
				if (node.ReferencedObject != null)
				{
					this.acceptKeyword("references");
					node.ReferencedObject.accept(this);
					if (node.ReferencedColumnList != null)
					{
						this.acceptSymbol("(");
						this.visitObjectNameList(node.ReferencedColumnList);
						this.acceptSymbol(")");
						return;
					}
				}
				break;
			case EConstraintType.check:
				this.acceptKeyword("check");
				if (node.CheckCondition != null)
				{
					this.acceptSymbol("(");
					node.CheckCondition.accept(this);
					this.acceptSymbol(")");
					return;
				}
				break;
			case EConstraintType.reference:
				this.acceptKeyword("references");
				if (node.ReferencedObject != null)
				{
					node.ReferencedObject.accept(this);
				}
				if (node.ReferencedColumnList != null)
				{
					this.acceptSymbol("(");
					this.visitObjectNameList(node.ReferencedColumnList);
					this.acceptSymbol(")");
					return;
				}
				break;
			case EConstraintType.default_value:
				this.acceptKeyword("default");
				node.DefaultExpression.accept(this);
				break;
			default:
				return;
			}
		}

		// Token: 0x06001115 RID: 4373 RVA: 0x00312424 File Offset: 0x00310624
		public override void preVisit(TTypeName node)
		{
			EDataType dataType = node.DataType;
			if (dataType <= EDataType.numeric_t)
			{
				if (dataType <= EDataType.int_t)
				{
					if (dataType <= EDataType.geometry_t)
					{
						switch (dataType)
						{
						case EDataType.generic_t:
							if (node.DataTypeObjectName != null)
							{
								node.DataTypeObjectName.accept(this);
								goto IL_C7B;
							}
							if (node.DataTypeName != null)
							{
								this.acceptIdentifier(node.DataTypeName);
								goto IL_C7B;
							}
							if (node.startToken != null)
							{
								this.acceptToken(node.startToken);
								goto IL_C7B;
							}
							goto IL_C7B;
						case EDataType.bfile_t:
							this.acceptKeyword("bfile");
							goto IL_C7B;
						case EDataType.bigint_t:
							this.acceptKeyword("bigint");
							goto IL_C7B;
						case EDataType.binary_t:
							this.acceptKeyword("binary");
							goto IL_C7B;
						case EDataType.binary_float_t:
							this.acceptKeyword("binary");
							this.acceptKeyword("float");
							goto IL_C7B;
						case EDataType.binary_double_t:
							this.acceptKeyword("binary");
							this.acceptKeyword("double");
							goto IL_C7B;
						case EDataType.binary_integer_t:
						case EDataType.binary_large_object_t:
						case EDataType.bit_varying_t:
						case EDataType.box_t:
						case EDataType.byte_t:
						case EDataType.bytea_t:
						case EDataType.byteint_t:
						case EDataType.char_for_bit_data_t:
						case EDataType.char_large_object_t:
						case EDataType.cidr_t:
						case EDataType.circle_t:
						case EDataType.cursor_t:
						case EDataType.datalink_t:
						case EDataType.datetimeoffset_t:
						case EDataType.datetime2_t:
						case EDataType.dbclob_t:
						case EDataType.enum_t:
							break;
						case EDataType.bit_t:
							this.acceptKeyword("bit");
							goto IL_C7B;
						case EDataType.blob_t:
							this.acceptKeyword("blob");
							goto IL_C7B;
						case EDataType.bool_t:
							this.acceptKeyword("boolean");
							goto IL_C7B;
						case EDataType.character_t:
							this.acceptKeyword("character");
							if (node.Length != null)
							{
								this.acceptSymbol("(");
								node.Length.accept(this);
								if (node.ByteUnit)
								{
									this.acceptKeyword("byte");
								}
								if (node.isCharUnit())
								{
									this.acceptKeyword("char");
								}
								this.acceptSymbol(")");
							}
							if (node.isVarying())
							{
								this.acceptKeyword("varying");
							}
							if (node.CharsetName != null)
							{
								this.acceptIdentifier(node.CharsetName);
								goto IL_C7B;
							}
							goto IL_C7B;
						case EDataType.char_t:
							this.acceptKeyword("char");
							if (node.isVarying())
							{
								this.acceptKeyword("varying");
							}
							if (node.Length != null)
							{
								this.acceptSymbol("(");
								node.Length.accept(this);
								if (node.ByteUnit)
								{
									this.acceptKeyword("byte");
								}
								if (node.isCharUnit())
								{
									this.acceptKeyword("char");
								}
								this.acceptSymbol(")");
							}
							if (node.CharsetName != null)
							{
								if (node.GSharpSqlParser != null && node.GSharpSqlParser.DbVendor == EDbVendor.dbvmysql)
								{
									this.acceptKeyword("CHARACTER");
									this.acceptKeyword("SET");
									this.acceptSpace(1);
									this.acceptIdentifier(node.CharsetName);
								}
								else
								{
									this.acceptSpace(1);
									this.acceptIdentifier(node.CharsetName);
								}
							}
							if (node.CollationName != null)
							{
								this.acceptKeyword("COLLATE");
								this.acceptSpace(1);
								this.acceptIdentifier(node.CollationName);
								goto IL_C7B;
							}
							goto IL_C7B;
						case EDataType.clob_t:
							this.acceptKeyword("clob");
							goto IL_C7B;
						case EDataType.date_t:
							this.acceptKeyword("date");
							goto IL_C7B;
						case EDataType.datetime_t:
							this.acceptKeyword("datetime");
							goto IL_C7B;
						case EDataType.decimal_t:
							this.acceptKeyword("decimal");
							this.visitPrecisionScale(node.Precision, node.Scale);
							goto IL_C7B;
						case EDataType.dec_t:
							this.acceptKeyword("dec");
							this.visitPrecisionScale(node.Precision, node.Scale);
							goto IL_C7B;
						case EDataType.double_t:
							this.acceptKeyword("double");
							this.acceptKeyword("precision");
							goto IL_C7B;
						case EDataType.float_t:
							this.acceptKeyword("float");
							if (node.Length != null)
							{
								this.acceptSymbol("(");
								node.Length.accept(this);
								this.acceptSymbol(")");
								goto IL_C7B;
							}
							goto IL_C7B;
						default:
							if (dataType == EDataType.geometry_t)
							{
								this.acceptKeyword("geometry");
								goto IL_C7B;
							}
							break;
						}
					}
					else
					{
						if (dataType == EDataType.integer_t)
						{
							this.acceptKeyword("integer");
							goto IL_C7B;
						}
						if (dataType == EDataType.int_t)
						{
							this.acceptKeyword("int");
							if (node.Length != null)
							{
								this.acceptSymbol("(");
								node.Length.accept(this);
								this.acceptSymbol(")");
								goto IL_C7B;
							}
							goto IL_C7B;
						}
					}
				}
				else if (dataType <= EDataType.interval_year_to_month_t)
				{
					if (dataType != EDataType.interval_day_to_second_t)
					{
						if (dataType == EDataType.interval_year_to_month_t)
						{
							this.acceptKeyword("interval");
							this.acceptKeyword("year");
							if (node.Length != null)
							{
								this.acceptSymbol("(");
								node.Length.accept(this);
								this.acceptSymbol(")");
							}
							this.acceptKeyword("to");
							this.acceptKeyword("month");
							goto IL_C7B;
						}
					}
					else
					{
						this.acceptKeyword("interval");
						this.acceptKeyword("day");
						if (node.Precision != null)
						{
							this.acceptSymbol("(");
							node.Precision.accept(this);
							this.acceptSymbol(")");
						}
						this.acceptKeyword("to");
						this.acceptKeyword("second");
						if (node.SecondsPrecision != null)
						{
							this.acceptSymbol("(");
							node.SecondsPrecision.accept(this);
							this.acceptSymbol(")");
							goto IL_C7B;
						}
						goto IL_C7B;
					}
				}
				else
				{
					if (dataType == EDataType.long_t)
					{
						this.acceptKeyword("long");
						goto IL_C7B;
					}
					switch (dataType)
					{
					case EDataType.long_raw_t:
						this.acceptKeyword("long");
						this.acceptKeyword("raw");
						goto IL_C7B;
					case EDataType.money_t:
						this.acceptKeyword("money");
						goto IL_C7B;
					case EDataType.nvarchar_t:
						if (node.isVarying())
						{
							this.acceptKeyword("nchar");
							this.acceptKeyword("varying");
						}
						else
						{
							this.acceptKeyword("nvarchar");
						}
						if (node.Length != null)
						{
							this.acceptSymbol("(");
							node.Length.accept(this);
							if (node.ByteUnit)
							{
								this.acceptKeyword("byte");
							}
							if (node.isCharUnit())
							{
								this.acceptKeyword("char");
							}
							this.acceptSymbol(")");
						}
						if (node.CharsetName != null)
						{
							this.acceptIdentifier(node.CharsetName);
							goto IL_C7B;
						}
						goto IL_C7B;
					case EDataType.nchar_t:
						this.acceptKeyword("nchar");
						if (node.isVarying())
						{
							this.acceptKeyword("varying");
						}
						if (node.Length != null)
						{
							this.acceptSymbol("(");
							node.Length.accept(this);
							if (node.ByteUnit)
							{
								this.acceptKeyword("byte");
							}
							if (node.isCharUnit())
							{
								this.acceptKeyword("char");
							}
							this.acceptSymbol(")");
						}
						if (node.CharsetName != null)
						{
							this.acceptIdentifier(node.CharsetName);
							goto IL_C7B;
						}
						goto IL_C7B;
					case EDataType.ncharacter_t:
						this.acceptKeyword("national");
						this.acceptKeyword("character");
						if (node.isVarying())
						{
							this.acceptKeyword("varying");
						}
						if (node.Length != null)
						{
							this.acceptSymbol("(");
							node.Length.accept(this);
							if (node.ByteUnit)
							{
								this.acceptKeyword("byte");
							}
							if (node.isCharUnit())
							{
								this.acceptKeyword("char");
							}
							this.acceptSymbol(")");
						}
						if (node.CharsetName != null)
						{
							this.acceptIdentifier(node.CharsetName);
							goto IL_C7B;
						}
						goto IL_C7B;
					case EDataType.nclob_t:
						this.acceptKeyword("nclob");
						goto IL_C7B;
					case EDataType.nvarchar2_t:
						this.acceptKeyword("nvarchar2");
						if (node.Length != null)
						{
							this.acceptSymbol("(");
							node.Length.accept(this);
							if (node.ByteUnit)
							{
								this.acceptKeyword("byte");
							}
							if (node.isCharUnit())
							{
								this.acceptKeyword("char");
							}
							this.acceptSymbol(")");
						}
						if (node.CharsetName != null)
						{
							this.acceptIdentifier(node.CharsetName);
							goto IL_C7B;
						}
						goto IL_C7B;
					case EDataType.number_t:
						this.acceptKeyword("number");
						this.visitPrecisionScale(node.Precision, node.Scale);
						goto IL_C7B;
					case EDataType.numeric_t:
						this.acceptKeyword("numeric");
						this.visitPrecisionScale(node.Precision, node.Scale);
						goto IL_C7B;
					}
				}
			}
			else if (dataType <= EDataType.timestamp_with_time_zone_t)
			{
				if (dataType <= EDataType.real_t)
				{
					if (dataType != EDataType.raw_t)
					{
						if (dataType == EDataType.real_t)
						{
							this.acceptKeyword("real");
							this.visitPrecisionScale(node.Precision, node.Scale);
							goto IL_C7B;
						}
					}
					else
					{
						this.acceptKeyword("raw");
						if (node.Length != null)
						{
							this.acceptSymbol("(");
							node.Length.accept(this);
							this.acceptSymbol(")");
							goto IL_C7B;
						}
						goto IL_C7B;
					}
				}
				else if (dataType != EDataType.smallint_t)
				{
					switch (dataType)
					{
					case EDataType.time_t:
						this.acceptKeyword("time");
						goto IL_C7B;
					case EDataType.timestamp_t:
						this.acceptKeyword("timestamp");
						if (node.Length != null)
						{
							this.acceptSymbol("(");
							node.Length.accept(this);
							this.acceptSymbol(")");
							goto IL_C7B;
						}
						goto IL_C7B;
					case EDataType.timestamp_with_local_time_zone_t:
						this.acceptKeyword("timestampe");
						if (node.Length != null)
						{
							this.acceptSymbol("(");
							node.Length.accept(this);
							this.acceptSymbol(")");
						}
						this.acceptKeyword("with");
						this.acceptKeyword("local");
						this.acceptKeyword("time");
						this.acceptKeyword("zone");
						goto IL_C7B;
					case EDataType.timestamp_with_time_zone_t:
						this.acceptKeyword("timestampe");
						if (node.Length != null)
						{
							this.acceptSymbol("(");
							node.Length.accept(this);
							this.acceptSymbol(")");
						}
						this.acceptKeyword("with");
						this.acceptKeyword("time");
						this.acceptKeyword("zone");
						goto IL_C7B;
					}
				}
				else
				{
					this.acceptKeyword("smallint");
					if (node.Length != null)
					{
						this.acceptSymbol("(");
						node.Length.accept(this);
						this.acceptSymbol(")");
						goto IL_C7B;
					}
					goto IL_C7B;
				}
			}
			else if (dataType <= EDataType.urowid_t)
			{
				if (dataType != EDataType.tinyint_t)
				{
					if (dataType == EDataType.urowid_t)
					{
						this.acceptKeyword("urowid");
						if (node.Length != null)
						{
							this.acceptSymbol("(");
							node.Length.accept(this);
							this.acceptSymbol(")");
							goto IL_C7B;
						}
						goto IL_C7B;
					}
				}
				else
				{
					this.acceptKeyword("tinyint");
					if (node.Length != null)
					{
						this.acceptSymbol("(");
						node.Length.accept(this);
						this.acceptSymbol(")");
						goto IL_C7B;
					}
					goto IL_C7B;
				}
			}
			else if (dataType != EDataType.varchar_t)
			{
				if (dataType != EDataType.varchar2_t)
				{
					switch (dataType)
					{
					case EDataType.signed_t:
						this.acceptKeyword("signed");
						goto IL_C7B;
					case EDataType.signed_integer_t:
						this.acceptKeyword("siged integer");
						goto IL_C7B;
					case EDataType.unsigned_integer_t:
						this.acceptKeyword("unsigned integer");
						goto IL_C7B;
					case EDataType.unsigned_t:
						this.acceptKeyword("unsigned");
						goto IL_C7B;
					}
				}
				else
				{
					this.acceptKeyword("varchar2");
					if (node.Length != null)
					{
						this.acceptSymbol("(");
						node.Length.accept(this);
						if (node.ByteUnit)
						{
							this.acceptKeyword("byte");
						}
						if (node.isCharUnit())
						{
							this.acceptKeyword("char");
						}
						this.acceptSymbol(")");
					}
					if (node.CharsetName != null)
					{
						this.acceptIdentifier(node.CharsetName);
						goto IL_C7B;
					}
					goto IL_C7B;
				}
			}
			else
			{
				if (node.isVarying())
				{
					this.acceptKeyword("char");
					this.acceptKeyword("varying");
				}
				else
				{
					this.acceptKeyword("varchar");
				}
				if (node.Length != null)
				{
					this.acceptSymbol("(");
					node.Length.accept(this);
					if (node.ByteUnit)
					{
						this.acceptKeyword("byte");
					}
					if (node.isCharUnit())
					{
						this.acceptKeyword("char");
					}
					this.acceptSymbol(")");
				}
				if (node.CharsetName != null)
				{
					this.acceptIdentifier(node.CharsetName);
					goto IL_C7B;
				}
				goto IL_C7B;
			}
			this.acceptKeyword(node.ToString());
			IL_C7B:
			if (node.signedToken != null)
			{
				this.acceptKeyword(node.signedToken.astext);
			}
			if (node.zeroFillToken != null)
			{
				this.acceptKeyword(node.zeroFillToken.astext);
			}
		}

		// Token: 0x06001116 RID: 4374 RVA: 0x003130E0 File Offset: 0x003112E0
		public override void preVisit(TKeepDenseRankClause node)
		{
			this.acceptKeyword("keep");
			this.acceptSymbol("(");
			this.acceptKeyword("dense_rank");
			if (node.First)
			{
				this.acceptKeyword("first");
			}
			if (node.Last)
			{
				this.acceptKeyword("last");
			}
			node.OrderBy.accept(this);
			this.acceptSymbol(")");
		}

		// Token: 0x06001117 RID: 4375 RVA: 0x0031314C File Offset: 0x0031134C
		public override void preVisit(TRollupCube node)
		{
			if (node.Operation == 2)
			{
				this.acceptKeyword("cube");
			}
			else if (node.Operation == 1)
			{
				this.acceptKeyword("rollup");
			}
			this.acceptSymbol("(");
			this.visitExprList(node.Items);
			this.acceptSymbol(")");
		}

		// Token: 0x06001118 RID: 4376 RVA: 0x003131A8 File Offset: 0x003113A8
		public override void preVisit(TGroupingSet node)
		{
			this.acceptKeyword("grouping");
			this.acceptKeyword("sets");
			this.acceptSymbol("(");
			for (int i = 0; i < node.Items.Count; i++)
			{
				node.Items.getGroupingSetItem(i).accept(this);
				if (i != node.Items.Count - 1)
				{
					this.acceptSymbol(",");
				}
			}
			this.acceptSymbol(")");
		}

		// Token: 0x06001119 RID: 4377 RVA: 0x00313224 File Offset: 0x00311424
		public override void preVisit(TGroupingSetItem node)
		{
			if (node.RollupCubeClause != null)
			{
				node.RollupCubeClause.accept(this);
				return;
			}
			if (node.Grouping_expression != null)
			{
				node.Grouping_expression.accept(this);
			}
		}

		// Token: 0x0600111A RID: 4378 RVA: 0x00313250 File Offset: 0x00311450
		public override void preVisit(TReturningClause node)
		{
			this.acceptKeyword("returning");
			this.visitExprList(node.ColumnValueList);
			if (node.BulkCollect)
			{
				this.acceptKeyword("bulk");
				this.acceptKeyword("collect");
			}
			this.acceptKeyword("into");
			this.visitExprList(node.VariableList);
		}

		// Token: 0x0600111B RID: 4379 RVA: 0x003132AC File Offset: 0x003114AC
		public override void preVisit(TDropIndexSqlStatement dropIndex)
		{
			this.acceptKeyword("drop");
			this.acceptKeyword("index");
			if (dropIndex.IndexName != null)
			{
				dropIndex.IndexName.accept(this);
			}
			if (dropIndex.DropIndexItemList != null && dropIndex.DropIndexItemList.Count > 0)
			{
				for (int i = 0; i < dropIndex.DropIndexItemList.Count; i++)
				{
					TDropIndexItem dropIndexItem = dropIndex.DropIndexItemList.getDropIndexItem(i);
					if (dropIndexItem.IndexName != null)
					{
						dropIndexItem.IndexName.accept(this);
					}
					if (dropIndexItem.ObjectName != null)
					{
						this.acceptKeyword("on");
						dropIndexItem.ObjectName.accept(this);
					}
				}
			}
		}

		// Token: 0x0600111C RID: 4380 RVA: 0x00313350 File Offset: 0x00311550
		public override void preVisit(TCreateIndexSqlStatement createIndex)
		{
			this.acceptKeyword("create");
			if (createIndex.NonClustered)
			{
				this.acceptKeyword("nonclustered");
			}
			if (createIndex.Clustered)
			{
				this.acceptKeyword("clustered");
			}
			EIndexType indexType = createIndex.IndexType;
			if (indexType != EIndexType.itUnique)
			{
				if (indexType == EIndexType.itBitMap)
				{
					this.acceptKeyword("bitmap");
				}
			}
			else
			{
				this.acceptKeyword("unique");
			}
			this.acceptKeyword("index");
			if (createIndex.IndexName != null)
			{
				createIndex.IndexName.accept(this);
			}
			if (createIndex.TableName != null)
			{
				this.acceptKeyword("on");
				createIndex.TableName.accept(this);
				if (createIndex.ColumnNameList != null && createIndex.ColumnNameList.Count > 0)
				{
					this.acceptSpace(1);
					this.acceptSymbol("(");
					createIndex.ColumnNameList.accept(this);
					this.acceptSymbol(")");
				}
			}
			if (createIndex.FilegroupOrPartitionSchemeName != null)
			{
				this.acceptKeyword("on");
				createIndex.FilegroupOrPartitionSchemeName.accept(this);
				if (createIndex.PartitionSchemeColumns != null && createIndex.PartitionSchemeColumns.Count > 0)
				{
					this.acceptSpace(1);
					this.acceptSymbol("(");
					createIndex.PartitionSchemeColumns.accept(this);
					this.acceptSymbol(")");
				}
			}
		}

		// Token: 0x0600111D RID: 4381 RVA: 0x00313494 File Offset: 0x00311694
		public override void preVisit(TOrderByItemList orderByList)
		{
			for (int i = 0; i < orderByList.Count; i++)
			{
				orderByList.getOrderByItem(i).accept(this);
				if (i != orderByList.Count - 1)
				{
					this.acceptSymbol(",");
				}
			}
		}

		// Token: 0x0600111E RID: 4382 RVA: 0x003134D5 File Offset: 0x003116D5
		public override void preVisit(TUseDatabase useDataBase)
		{
			this.acceptKeyword("use");
			if (useDataBase.DatabaseName != null)
			{
				useDataBase.DatabaseName.accept(this);
			}
		}

		// Token: 0x0600111F RID: 4383 RVA: 0x003134F8 File Offset: 0x003116F8
		public override void preVisit(TPlsqlCreateProcedure procedure)
		{
			this.acceptKeyword("create");
			this.acceptKeyword("procedure");
			if (procedure.ProcedureName != null)
			{
				procedure.ProcedureName.accept(this);
			}
			if (procedure.ParameterDeclarations != null && procedure.ParameterDeclarations.Count > 0)
			{
				this.acceptSymbol("(");
				procedure.ParameterDeclarations.accept(this);
				this.acceptSymbol(")");
			}
			this.acceptNewline();
			if (procedure.InvokerRightsClause != null)
			{
				procedure.InvokerRightsClause.accept(this);
			}
			this.acceptKeyword("as");
			if (procedure.DeclareStatements != null && procedure.DeclareStatements.Count > 0)
			{
				this.acceptNewline();
				procedure.DeclareStatements.accept(this);
				if (procedure.DeclareStatements.Count == 1)
				{
					this.acceptSemicolon();
				}
			}
			this.acceptNewline();
			this.acceptKeyword("begin");
			if (procedure.BodyStatements != null && procedure.BodyStatements.Count > 0)
			{
				this.acceptNewline();
				procedure.BodyStatements.accept(this);
				if (procedure.BodyStatements.Count == 1)
				{
					this.acceptSemicolon();
				}
			}
			this.acceptNewline();
			this.acceptKeyword("end");
			this.acceptSemicolon();
		}

		// Token: 0x06001120 RID: 4384 RVA: 0x0031362C File Offset: 0x0031182C
		public override void preVisit(TInvokerRightsClause clause)
		{
			this.acceptKeyword("authid");
			if (clause.Definer != null)
			{
				clause.Definer.accept(this);
			}
		}

		// Token: 0x06001121 RID: 4385 RVA: 0x0031364D File Offset: 0x0031184D
		public override void preVisit(TIndexHint clause)
		{
			this.visitNodeByToken(clause);
		}

		// Token: 0x06001122 RID: 4386 RVA: 0x00313656 File Offset: 0x00311856
		internal virtual void visitPrecisionScale(TConstant precision, TConstant scale)
		{
			if (precision != null)
			{
				this.acceptSymbol("(");
				precision.accept(this);
				if (scale != null)
				{
					this.acceptSymbol(",");
					scale.accept(this);
				}
				this.acceptSymbol(")");
			}
		}

		// Token: 0x06001123 RID: 4387 RVA: 0x00313690 File Offset: 0x00311890
		internal virtual void visitExprList(TExpressionList expressionList)
		{
			for (int i = 0; i < expressionList.Count; i++)
			{
				expressionList.getExpression(i).accept(this);
				if (i != expressionList.Count - 1)
				{
					this.acceptSymbol(",");
				}
			}
		}

		// Token: 0x06001124 RID: 4388 RVA: 0x003136D4 File Offset: 0x003118D4
		internal virtual void visitObjectNameList(TObjectNameList objectNameList)
		{
			for (int i = 0; i < objectNameList.Count; i++)
			{
				objectNameList.getObjectName(i).accept(this);
				if (i != objectNameList.Count - 1)
				{
					this.acceptSymbol(",");
				}
			}
		}

		// Token: 0x06001125 RID: 4389 RVA: 0x00313718 File Offset: 0x00311918
		internal virtual void visitIndexColNameList(List<TIndexColName> indexColNameList)
		{
			for (int i = 0; i < indexColNameList.Count; i++)
			{
				indexColNameList[i].ColumnName.accept(this);
				if (i != indexColNameList.Count - 1)
				{
					this.acceptSymbol(",");
				}
			}
		}

		// Token: 0x06001126 RID: 4390 RVA: 0x00313760 File Offset: 0x00311960
		internal virtual void visitCTEList(TCTEList cteList)
		{
			for (int i = 0; i < cteList.Count; i++)
			{
				cteList.getCTE(i).accept(this);
				if (i != cteList.Count - 1)
				{
					this.acceptSymbol(",");
					this.acceptNewline();
				}
			}
		}

		// Token: 0x06001127 RID: 4391 RVA: 0x003137A8 File Offset: 0x003119A8
		internal virtual void visitJoinList(TJoinList joinList)
		{
			for (int i = 0; i < joinList.Count; i++)
			{
				this.acceptNewline();
				joinList.getJoin(i).accept(this);
				if (i != joinList.Count - 1)
				{
					this.acceptSymbol(",");
				}
			}
		}

		// Token: 0x06001128 RID: 4392 RVA: 0x003137F0 File Offset: 0x003119F0
		internal virtual void visitResultColumnList(TResultColumnList resultColumnList)
		{
			for (int i = 0; i < resultColumnList.Count; i++)
			{
				resultColumnList.getResultColumn(i).accept(this);
				if (i != resultColumnList.Count - 1)
				{
					this.acceptSymbol(",");
				}
			}
		}

		// Token: 0x06001129 RID: 4393 RVA: 0x00313834 File Offset: 0x00311A34
		internal virtual void visitNodeByToken(TParseTreeNode node)
		{
			if (node.SourceTokenList.Count > 0)
			{
				this.acceptSpace(1);
				for (int i = 0; i < node.SourceTokenList.Count; i++)
				{
					this.acceptToken(node.SourceTokenList.get(i));
				}
				this.acceptSpace(1);
				return;
			}
		}

		// Token: 0x0400139B RID: 5019
		private TScriptWriter scriptWriter;
	}
}
